Record Windows and Linux direct state editing acceptance

README.md

@@ -53,8 +53,6 @@ The example opens in an architecture view with work nested inside its performers
 
 **Model explorer** groups roots by engineering purpose and opens one container's direct children. Breadcrumbs navigate ownership; **Allocated work** is listed separately. Search names, kinds or `@aliases` to find elements with ancestor context. Results are paged in groups of 100. **Collapse all** folds the outline; **Locate** clears the filter and reveals the selected element's ancestry.
 
-**Data & interfaces** separates exchange nature from mechanism, supports bounded reusable types and typed defaults, and gives each interface item allocation its own protocol and artifact identity. Operation parameters have provider-side directions; qualified message paths distinguish repeated Record uses. Record/item/interface specialization preserves inherited identities. See the [data contract](docs/language.rst) for exact semantics and compatibility.
-
 The inspector exposes typed properties, references, ordered lists, aliases and UUID identity. Applying or navigating away attempts to commit the draft; invalid values remain editable. **Escaped strings (advanced)** uses quoted JSON escapes for exact tabs, line breaks and carriage returns, for example `"First\nSecond"`. UUID changes atomically update dependent references. Accepted model/source history retains up to 100 edits within an estimated 32 MiB history budget.
 
 Choose **Interaction**, **Functional exchange** or **Boundary exchange** in the diagram palette, then click the source and a highlighted compatible target, or drag between them. Functional exchanges use output/input ports; function cards create or reuse real ports atomically. Boundary exchanges use compatible component ports. Middle-button drag pans without losing the chosen source; arrow keys also pan while drawing with the canvas focused. Click empty space to restart, or Escape to cancel. Each completed connection is one model/source history operation; edit its name and carried items in Properties.
@@ -72,7 +70,7 @@ In the state view, **Select / move** drags vertices and containers without repar
 **Textual model** has a source-file folder tree, per-file drafts, syntax highlighting, live linting and explicit **Apply all**. Collapse/Locate navigate the hierarchy; collapsed folders retain draft and diagnostic indicators. Right-click a file for contextual actions. Projects can use relative includes to organize source into files. For example:
 
 ```text
-arcadia 4;
+arcadia 3;
 project harbor "Harbor assistance" {
     oa_entity control "Harbor control" {}
     oa_activity respond "Respond to requests" {

crates/oa-core/examples/routing_workshop.rs

@@ -507,7 +507,6 @@ fn workshop() -> Project {
         let baseline = TraceBaseline {
             oa: p.properties(t.oa).unwrap(),
             sa: p.properties(t.sa).unwrap(),
-            semantic: None,
         };
         p.traces.get_mut(&id).unwrap().baseline = Some(baseline);
     }

crates/oa-core/src/demo.rs

@@ -34,7 +34,10 @@ fn occurrence(
     id
 }
 fn port(p: &mut Project, owner: Id, name: &str, direction: PortDirection, interface: Id) -> Id {
-    let items = crate::data::interface_items(p, interface);
+    let items = match p.elements[&interface].shared() {
+        Some(SharedBody::Interface { items }) => items.clone(),
+        _ => vec![],
+    };
     let contract = if p.elements[&owner].kind() == Kind::Function {
         if direction == PortDirection::Out {
             PortContract::FunctionOutput {
@@ -111,7 +114,6 @@ fn trace(p: &mut Project, oa: Id, sa: Id, kind: TraceKind) {
             baseline: Some(TraceBaseline {
                 oa: p.properties(oa).unwrap(),
                 sa: p.properties(sa).unwrap(),
-                semantic: None,
             }),
         },
     );
@@ -166,11 +168,6 @@ pub fn coastal_rescue() -> Project {
         "Distress report",
         None,
     );
-    if let Some(SharedBody::ExchangeItem { mechanism, .. }) =
-        p.elements.get_mut(&oa_item).unwrap().shared_mut()
-    {
-        *mechanism = ExchangeMechanism::Event;
-    }
     p.relate(RelationKind::Allocation, "Reports distress", vessel, report);
     p.relate(
         RelationKind::Allocation,
@@ -311,11 +308,6 @@ pub fn coastal_rescue() -> Project {
         "Digital distress report",
         None,
     );
-    if let Some(SharedBody::ExchangeItem { mechanism, .. }) =
-        p.elements.get_mut(&information).unwrap().shared_mut()
-    {
-        *mechanism = ExchangeMechanism::Event;
-    }
     let material = add(
         &mut p,
         Kind::ExchangeItem,
@@ -325,8 +317,6 @@ pub fn coastal_rescue() -> Project {
     );
     *p.elements.get_mut(&material).unwrap().shared_mut().unwrap() = SharedBody::ExchangeItem {
         kind: ExchangeItemKind::Material,
-        mechanism: ExchangeMechanism::Flow,
-        supertype: None,
     };
     let energy = add(
         &mut p,
@@ -337,8 +327,6 @@ pub fn coastal_rescue() -> Project {
     );
     *p.elements.get_mut(&energy).unwrap().shared_mut().unwrap() = SharedBody::ExchangeItem {
         kind: ExchangeItemKind::Energy,
-        mechanism: ExchangeMechanism::Flow,
-        supertype: None,
     };
     let field = add(
         &mut p,
@@ -352,9 +340,6 @@ pub fn coastal_rescue() -> Project {
         minimum: 1,
         maximum: Some(1),
         unit: "degrees north".into(),
-        direction: ParameterDirection::Unspecified,
-        storage: FieldStorage::Value,
-        default: None,
     };
     let interface = add(
         &mut p,
@@ -363,12 +348,13 @@ pub fn coastal_rescue() -> Project {
         "Distress reporting interface",
         None,
     );
-    p.relate(
-        RelationKind::InterfaceItemAllocation,
-        "Distress payload",
-        interface,
-        information,
-    );
+    *p.elements
+        .get_mut(&interface)
+        .unwrap()
+        .shared_mut()
+        .unwrap() = SharedBody::Interface {
+        items: vec![information],
+    };
     let vessel_port = port(
         &mut p,
         actor,

crates/oa-core/src/language.rs

@@ -1,6 +1,4 @@
-//! Typed OA/SA language, tolerant source analysis, and explicit V1/V2/V3/V4 migration.
-#[path = "language/semantic_source.rs"]
-mod semantic_source;
+//! Typed OA/SA language, tolerant source analysis, and explicit V1/V2 migration.
 #[path = "migration_v2/source.rs"]
 mod v2_source;
 use crate::*;
@@ -342,8 +340,6 @@ fn reference_field(key: &str) -> bool {
             | "referenced"
             | "local"
             | "field"
-            | "path"
-            | "supertype"
             | "sender"
             | "receiver"
             | "action"
@@ -382,14 +378,10 @@ fn enum_field(key: &str) -> bool {
             | "message_kind"
             | "transition_kind"
             | "side"
-            | "mechanism"
-            | "storage"
-            | "transmission"
-            | "acquisition"
     )
 }
 
-/// Parse V5, or explicitly migrate a valid V1/V2/V3/V4 source candidate. Parsing never
+/// Parse V3, or explicitly migrate a valid V1/V2 source candidate. Parsing never
 /// adopts a model and never overwrites an editor draft.
 pub fn parse(source: &str) -> Result<Project, Vec<Diagnostic>> {
     parse_limited(source, ParseLimits::UNLIMITED)
@@ -554,7 +546,7 @@ fn offset_for(source: &str, line: usize, column: usize) -> usize {
 /// nested records are ordinary language fields; JSON documents are not embedded.
 pub fn format(project: &Project) -> String {
     let mut out = std::format!(
-        "arcadia {SCHEMA_VERSION};\nproject {} {} id \"{}\" {{\n    description {};\n\n",
+        "arcadia 3;\nproject {} {} id \"{}\" {{\n    description {};\n\n",
         project.alias,
         quote(&project.name),
         project.id,
@@ -745,10 +737,6 @@ fn write_value(
     indent: usize,
     aliases: &BTreeMap<Id, String>,
 ) {
-    if key == "semantic" {
-        semantic_source::write(out, value, indent);
-        return;
-    }
     match value {
         Value::Null => out.push_str("none"),
         Value::Bool(v) => out.push_str(if *v { "true" } else { "false" }),
@@ -792,7 +780,6 @@ enum Ast {
     Literal(Value, usize),
     Word(String, usize),
     Reference(String, usize),
-    HistoricalUuid(Id, usize),
     Array(Vec<Ast>, usize),
     Object(BTreeMap<String, Ast>, usize),
 }
@@ -802,20 +789,12 @@ impl Ast {
             Self::Literal(_, p)
             | Self::Word(_, p)
             | Self::Reference(_, p)
-            | Self::HistoricalUuid(_, p)
             | Self::Array(_, p)
             | Self::Object(_, p) => *p,
         }
     }
     fn resolve(&self, key: &str, aliases: &BTreeMap<String, Id>) -> Result<Value, Error> {
         match self {
-            Self::HistoricalUuid(_, _) => Err(Error {
-                code: "invalid_source",
-                offset: self.offset(),
-                message:
-                    "A uuid literal is allowed only in a typed historical semantic reference slot."
-                        .into(),
-            }),
             Self::Word(word, offset) => {
                 if !enum_field(key) {
                     return Err(Error {
@@ -983,7 +962,6 @@ pub(crate) struct EditValue {
 pub(crate) enum EditKind {
     Atom,
     Reference(String),
-    HistoricalUuid(Id),
     Record(BTreeMap<String, EditField>),
     List(Vec<EditValue>),
 }
@@ -1096,7 +1074,7 @@ fn edit_positions(
             let span = Span {
                 start: ast.offset(),
                 end: match ast {
-                    Ast::Reference(..) | Ast::HistoricalUuid(..) => self.tokens[index + 1].span.end,
+                    Ast::Reference(..) => self.tokens[index + 1].span.end,
                     _ => self.ends[index],
                 },
             };
@@ -1106,7 +1084,6 @@ fn edit_positions(
                     EditKind::List(items.iter().map(|item| self.value(item)).collect())
                 }
                 Ast::Reference(alias, _) => EditKind::Reference(alias.clone()),
-                Ast::HistoricalUuid(id, _) => EditKind::HistoricalUuid(*id),
                 _ => EditKind::Atom,
             };
             EditValue { span, kind }
@@ -1287,16 +1264,6 @@ impl Parser<'_> {
         let token = self.current();
         let offset = token.span.start;
         match self.text() {
-            "uuid" => {
-                self.cursor += 1;
-                let value = self.quoted()?;
-                let id = Id::parse_str(&value).map_err(|_| Error {
-                    code: "invalid_source",
-                    offset,
-                    message: "Expected a UUID after uuid.".into(),
-                })?;
-                Ok(Ast::HistoricalUuid(id, offset))
-            }
             "@" => {
                 self.cursor += 1;
                 Ok(Ast::Reference(self.identifier()?, offset))
@@ -1370,12 +1337,12 @@ impl Parser<'_> {
                     .map(|(key, span)| ((d.id, key.clone()), span.start)),
             );
         }
-        let decoded =
+        let project =
             resolve_declarations(header.project, &unit.declarations, &aliases, self.limits)
                 .map_err(|(_, error)| error)?;
         Ok(ParsedDocument {
-            project: decoded.project,
-            migration: decoded.migration,
+            project,
+            migration: None,
             locations,
             fields,
         })
@@ -1383,11 +1350,9 @@ impl Parser<'_> {
     fn unit(&mut self, entry: bool, includes_allowed: bool) -> Result<SourceUnit, Error> {
         let mut header = if entry {
             self.take("arcadia")?;
-            if !matches!(self.text(), "3" | "4" | "5") {
-                return Err(self
-                    .error("Unsupported schema version: expected 'arcadia 3;', 'arcadia 4;' or 'arcadia 5;'."));
+            if self.text() != "3" {
+                return Err(self.error("Unsupported schema version: expected 'arcadia 3;'."));
             }
-            let schema_version = self.text().parse().expect("checked source version");
             self.cursor += 1;
             self.take(";")?;
             let start = self.current().span.start;
@@ -1400,7 +1365,7 @@ impl Parser<'_> {
             self.take("{")?;
             Some(SourceHeader {
                 project: Project {
-                    schema_version,
+                    schema_version: SCHEMA_VERSION,
                     id,
                     alias,
                     name,
@@ -1575,21 +1540,14 @@ pub(crate) fn resolve_declarations(
     declarations: &[Declaration],
     aliases: &BTreeMap<String, Id>,
     limits: ParseLimits,
-) -> Result<crate::persistence::DecodeResult, (usize, Error)> {
-    let legacy = project.schema_version == 3;
-    let mut legacy_elements = serde_json::Map::new();
+) -> Result<Project, (usize, Error)> {
     let mut nodes = Vec::new();
     for (index, declaration) in declarations.iter().enumerate() {
         (|| -> Result<(), Error> {
             let mut fields = declaration
                 .fields
                 .iter()
-                .map(|(k, v)| {
-                    let value = if matches!(declaration.kind, DeclKind::Trace) && k == "baseline" {
-                        semantic_source::resolve_baseline(v, aliases, project.schema_version)?
-                    } else { v.resolve(k, aliases)? };
-                    Ok((k.clone(), value))
-                })
+                .map(|(k, v)| Ok((k.clone(), v.resolve(k, aliases)?)))
                 .collect::<Result<Map<_, _>, Error>>()?;
             let d = declaration;
             let conversion_error = |message: String| Error {
@@ -1603,9 +1561,6 @@ pub(crate) fn resolve_declarations(
             };
             match d.kind {
                 DeclKind::Element(kind, layer) => {
-                    if legacy && !crate::persistence::v3::element_allowed(serde_json::to_value(kind).unwrap().as_str().unwrap()) {
-                        return Err(conversion_error("Element constructor was not part of schema3.".into()));
-                    }
                     let description =
                         take_string(&mut fields, "description", "").map_err(&conversion_error)?;
                     let explicit_parent = d.fields.contains_key("parent");
@@ -1646,17 +1601,9 @@ pub(crate) fn resolve_declarations(
                         *viewpoint = ScenarioViewpoint::MixedLegacy;
                     }
                     let mut body = serde_json::to_value(initial).unwrap();
-                    let defaults = if legacy {
-                        crate::persistence::v3::legacy_defaults(kind)
-                            .and_then(|value| value.as_object().cloned())
-                            .unwrap_or_else(|| payload(&body))
-                    } else { payload(&body) };
-                    let body_fields = merge_fields(defaults, fields).map_err(&conversion_error)?;
+                    let body_fields =
+                        merge_fields(payload(&body), fields).map_err(&conversion_error)?;
                     replace_payload(&mut body, body_fields);
-                    if legacy {
-                        legacy_elements.insert(d.id.to_string(), serde_json::json!({"id":d.id,"alias":d.alias,"name":d.name,"description":description,"parent":parent,"body":body}));
-                        return Ok(());
-                    }
                     let body: ElementBody = serde_json::from_value(body)
                         .map_err(|e| conversion_error(e.to_string()))?;
                     if body.kind() != kind || body.layer() != layer {
@@ -1677,9 +1624,6 @@ pub(crate) fn resolve_declarations(
                     );
                 }
                 DeclKind::Relation(kind) => {
-                    if legacy && !crate::persistence::v3::relation_allowed(serde_json::to_value(kind).unwrap().as_str().unwrap()) {
-                        return Err(conversion_error("Relation constructor was not part of schema3.".into()));
-                    }
                     let description =
                         take_string(&mut fields, "description", "").map_err(&conversion_error)?;
                     let required: &[&str] = if kind == RelationKind::FunctionalExchange {
@@ -1761,12 +1705,8 @@ pub(crate) fn resolve_declarations(
                     let mut record = merge_fields(defaults.as_object().unwrap().clone(), fields)
                         .map_err(&conversion_error)?;
                     header(&mut record, d, true);
-                    let trace = if project.schema_version < 5 {
-                        let old: crate::persistence::v4::Trace4 = serde_json::from_value(Value::Object(record)).map_err(|e| conversion_error(e.to_string()))?;
-                        Trace::from(old)
-                    } else {
-                        serde_json::from_value(Value::Object(record)).map_err(|e| conversion_error(e.to_string()))?
-                    };
+                    let trace = serde_json::from_value(Value::Object(record))
+                        .map_err(|e| conversion_error(e.to_string()))?;
                     project.traces.insert(d.id, trace);
                 }
             }
@@ -1785,74 +1725,6 @@ pub(crate) fn resolve_declarations(
             .map_err(|error| (index, error))?;
         target.nodes.insert(node.id, node);
     }
-    if legacy {
-        let mut value = serde_json::to_value(&project).expect("project serialization");
-        value["elements"] = Value::Object(legacy_elements);
-        let migrated = serde_json::from_value(value)
-            .map_err(crate::persistence::FileError::Json)
-            .and_then(|old| crate::persistence::v3::migrate(old, limits))
-            .map_err(|error| {
-                let issue = if let crate::persistence::FileError::Model { issues, .. } = &error {
-                    issues.first()
-                } else {
-                    None
-                };
-                let index = issue
-                    .and_then(|issue| issue.element)
-                    .and_then(|id| declarations.iter().position(|d| d.id == id))
-                    .unwrap_or(usize::MAX);
-                let offset = declarations.get(index).map_or(0, |d| {
-                    issue
-                        .and_then(|issue| issue.field.as_ref())
-                        .and_then(|field| d.field_spans.get(field))
-                        .map_or(d.offset, |span| span.start)
-                });
-                (
-                    index,
-                    Error {
-                        code: if matches!(error, crate::persistence::FileError::Limit(_)) {
-                            "model_limit"
-                        } else {
-                            "migration_error"
-                        },
-                        offset,
-                        message: error.to_string(),
-                    },
-                )
-            })?;
-        for (index, d) in declarations.iter().enumerate() {
-            if let DeclKind::Element(kind, layer) = d.kind {
-                let body = &migrated.project.elements[&d.id].body;
-                if body.kind() != kind || body.layer() != layer {
-                    return Err((
-                        index,
-                        Error {
-                            code: "invalid_source",
-                            offset: d.offset,
-                            message: "Declaration kind disagrees with its typed body.".into(),
-                        },
-                    ));
-                }
-            }
-        }
-        return Ok(migrated);
-    }
-    if project.schema_version == 4 {
-        return crate::persistence::v4::finish(project, limits).map_err(|error| {
-            (
-                usize::MAX,
-                Error {
-                    code: if matches!(error, crate::persistence::FileError::Limit(_)) {
-                        "model_limit"
-                    } else {
-                        "migration_error"
-                    },
-                    offset: 0,
-                    message: error.to_string(),
-                },
-            )
-        });
-    }
     limits.check_model(&project).map_err(|message| {
         (
             usize::MAX,
@@ -1863,10 +1735,7 @@ pub(crate) fn resolve_declarations(
             },
         )
     })?;
-    Ok(crate::persistence::DecodeResult {
-        project,
-        migration: None,
-    })
+    Ok(project)
 }
 
 fn header(fields: &mut Map<String, Value>, d: &Declaration, named: bool) {
@@ -2647,8 +2516,3 @@ pub(crate) mod legacy {
         }
     }
 }
-
-/// Closed historical facet identity for the targeted source writer.
-pub(crate) fn semantic_row_key(source: &str, origins: &BTreeMap<Id, Id>) -> Option<String> {
-    semantic_source::row_key(source, origins)
-}

crates/oa-core/src/language/semantic_source.rs

@@ -1,203 +0,0 @@
-//! Typed historical source leaves; live alias resolution remains in the parent.
-use super::*;
-use crate::semantic::{HistoricalSourceKind, SemanticBaseline, historical_source_slots};
-
-fn error(ast: &Ast, message: impl Into<String>) -> Error {
-    Error {
-        code: "invalid_source",
-        offset: ast.offset(),
-        message: message.into(),
-    }
-}
-
-fn raw(ast: &Ast) -> Result<Value, Error> {
-    Ok(match ast {
-        Ast::Literal(value, _) => value.clone(),
-        Ast::Word(value, _) => Value::String(value.clone()),
-        Ast::HistoricalUuid(value, _) => Value::String(value.to_string()),
-        Ast::Reference(_, _) => {
-            return Err(error(
-                ast,
-                "Historical semantic references require uuid \"...\", not @alias.",
-            ));
-        }
-        Ast::Array(values, _) => Value::Array(values.iter().map(raw).collect::<Result<_, _>>()?),
-        Ast::Object(fields, _) => Value::Object(
-            fields
-                .iter()
-                .map(|(key, value)| Ok((key.clone(), raw(value)?)))
-                .collect::<Result<_, Error>>()?,
-        ),
-    })
-}
-
-fn validate_tokens(
-    ast: &Ast,
-    path: &mut Vec<String>,
-    slots: &BTreeMap<Vec<String>, HistoricalSourceKind>,
-) -> Result<(), Error> {
-    match ast {
-        Ast::Object(fields, _) => {
-            for (key, value) in fields {
-                path.push(key.clone());
-                validate_tokens(value, path, slots)?;
-                path.pop();
-            }
-        }
-        Ast::Array(values, _) => {
-            for (index, value) in values.iter().enumerate() {
-                path.push(index.to_string());
-                validate_tokens(value, path, slots)?;
-                path.pop();
-            }
-        }
-        _ => match (slots.get(path), ast) {
-            (Some(HistoricalSourceKind::Reference), Ast::HistoricalUuid(..))
-            | (Some(HistoricalSourceKind::Enum), Ast::Word(..)) => {}
-            (Some(HistoricalSourceKind::Reference), _) => {
-                return Err(error(
-                    ast,
-                    "This historical reference requires uuid \"...\".",
-                ));
-            }
-            (Some(HistoricalSourceKind::Enum), _) => {
-                return Err(error(
-                    ast,
-                    "This typed historical enum requires an unquoted enum word.",
-                ));
-            }
-            (None, Ast::HistoricalUuid(..)) => {
-                return Err(error(
-                    ast,
-                    "A uuid literal is allowed only in a typed historical reference slot.",
-                ));
-            }
-            (None, Ast::Word(..)) => {
-                return Err(error(
-                    ast,
-                    "This historical text value requires a quoted string.",
-                ));
-            }
-            _ => {}
-        },
-    }
-    Ok(())
-}
-
-pub(super) fn resolve_baseline(
-    ast: &Ast,
-    aliases: &BTreeMap<String, Id>,
-    version: u32,
-) -> Result<Value, Error> {
-    let Ast::Object(fields, _) = ast else {
-        return ast.resolve("baseline", aliases);
-    };
-    let mut resolved = Map::new();
-    for (key, value) in fields {
-        if key != "semantic" {
-            resolved.insert(key.clone(), value.resolve(key, aliases)?);
-            continue;
-        }
-        if version < 5 {
-            return Err(error(
-                value,
-                "Semantic trace baselines require schema/source5; the older baseline contains prose only.",
-            ));
-        }
-        if matches!(value, Ast::Literal(Value::Null, _)) {
-            resolved.insert(key.clone(), Value::Null);
-            continue;
-        }
-        let json = raw(value)?;
-        let baseline: SemanticBaseline = serde_json::from_value(json.clone())
-            .map_err(|cause| error(value, format!("Invalid semantic baseline: {cause}")))?;
-        let slots = historical_source_slots(&baseline).into_iter().collect();
-        validate_tokens(value, &mut vec![], &slots)?;
-        resolved.insert(key.clone(), json);
-    }
-    Ok(Value::Object(resolved))
-}
-
-pub(super) fn write(out: &mut String, value: &Value, indent: usize) {
-    if value.is_null() {
-        out.push_str("none");
-        return;
-    }
-    let baseline: SemanticBaseline =
-        serde_json::from_value(value.clone()).expect("typed semantic baseline");
-    let slots = historical_source_slots(&baseline).into_iter().collect();
-    write_at(out, value, indent, &mut vec![], &slots);
-}
-
-fn write_at(
-    out: &mut String,
-    value: &Value,
-    indent: usize,
-    path: &mut Vec<String>,
-    slots: &BTreeMap<Vec<String>, HistoricalSourceKind>,
-) {
-    match value {
-        Value::Null => out.push_str("none"),
-        Value::Bool(value) => out.push_str(if *value { "true" } else { "false" }),
-        Value::Number(value) => out.push_str(&value.to_string()),
-        Value::String(value) => match slots.get(path) {
-            Some(HistoricalSourceKind::Reference) => {
-                out.push_str("uuid ");
-                out.push_str(&quote(value));
-            }
-            Some(HistoricalSourceKind::Enum) => out.push_str(value),
-            None => out.push_str(&quote(value)),
-        },
-        Value::Array(values) => {
-            out.push('[');
-            for (index, value) in values.iter().enumerate() {
-                if index != 0 {
-                    out.push_str(", ");
-                }
-                path.push(index.to_string());
-                write_at(out, value, indent, path, slots);
-                path.pop();
-            }
-            out.push(']');
-        }
-        Value::Object(fields) => {
-            out.push_str("{\n");
-            for (key, value) in fields {
-                out.push_str(&"    ".repeat(indent + 1));
-                out.push_str(key);
-                out.push(' ');
-                path.push(key.clone());
-                write_at(out, value, indent + 1, path, slots);
-                path.pop();
-                out.push_str(";\n");
-            }
-            out.push_str(&"    ".repeat(indent));
-            out.push('}');
-        }
-    }
-}
-
-/// Recognize only complete typed facet rows. Their closed selector, with real
-/// identity provenance applied, owns comments when review rows reorder.
-pub(super) fn row_key(source: &str, origins: &BTreeMap<Id, Id>) -> Option<String> {
-    let mut parser = Parser {
-        source,
-        tokens: strict_tokens(source).ok()?,
-        cursor: 0,
-        value_depth: 0,
-        limits: ParseLimits::UNLIMITED,
-    };
-    let ast = parser.value().ok()?;
-    let facet = serde_json::from_value(raw(&ast).ok()?).ok()?;
-    let mut baseline = SemanticBaseline {
-        facets: vec![facet],
-    };
-    crate::semantic::visit_semantic_references(&mut baseline, |id| {
-        if let Some(original) = origins.get(id) {
-            *id = *original;
-        }
-    });
-    serde_json::to_string(&baseline.facets[0].selector())
-        .ok()
-        .map(|key| format!("semantic:{key}"))
-}

crates/oa-core/src/language_nesting_tests.rs

@@ -3,7 +3,7 @@ use crate::source_project::{ProjectLimits, SourceBundle, compile_bundle, lint_bu
 
 fn project_source(body: &str) -> String {
     format!(
-        "arcadia 5; project model \"Model\" id \"00000000-0000-0000-0000-000000000001\" {{\n{body}\n}}"
+        "arcadia 3; project model \"Model\" id \"00000000-0000-0000-0000-000000000001\" {{\n{body}\n}}"
     )
 }
 
@@ -177,7 +177,7 @@ fn nested_fragment_id_stabilization_preserves_comments_and_indexes_real_bytes()
         files: BTreeMap::from([
             (
                 "project.arcadia".into(),
-                "arcadia 5; project model \"Model\" { include \"children.arcadia\"; }".into(),
+                "arcadia 3; project model \"Model\" { include \"children.arcadia\"; }".into(),
             ),
             (
                 "children.arcadia".into(),
@@ -300,7 +300,7 @@ fn deep_declaration_parsing_and_positions_use_a_bounded_rust_stack() {
 
 #[test]
 fn tolerant_nested_analysis_retains_closed_children_before_an_unfinished_sibling() {
-    let source = "arcadia 5; project model \"航海\" {\noa_activity outer_one \"Outer\" {\n oa_activity ready \"Ready\" { description \"} is text\"; }\n oa_activity unfinished \"Unfinished\" { description \"unterminated";
+    let source = "arcadia 3; project model \"航海\" {\noa_activity outer_one \"Outer\" {\n oa_activity ready \"Ready\" { description \"} is text\"; }\n oa_activity unfinished \"Unfinished\" { description \"unterminated";
     let analysis = analyze(source);
     let ready = analysis
         .declarations
@@ -406,34 +406,12 @@ fn checked_in_source_project() -> SourceBundle {
 fn checked_in_nested_example_has_stable_ids_typed_exchanges_and_three_clear_views() {
     let input = checked_in_source_project();
     let compiled = compile_bundle(&input, ProjectLimits::default()).unwrap();
-    assert_eq!(compiled.decoded.migration.as_ref().unwrap().from_schema, 3);
-    for (path, source) in &input.files {
-        let unit = parse_unit(source, path == &input.entry, ParseLimits::UNLIMITED).unwrap();
-        assert!(
-            unit.header
-                .as_ref()
-                .is_none_or(|header| header.id_insertion.is_none())
-        );
-        for declaration in unit.declarations {
-            assert!(
-                declaration.id_insertion.is_none(),
-                "every example identity is already explicit"
-            );
-            assert_eq!(
-                identity(&compiled.decoded.project, &declaration.alias),
-                declaration.id
-            );
-        }
-    }
-    let reopened = compile_bundle(&compiled.bundle, ProjectLimits::default()).unwrap();
-    assert_eq!(reopened.bundle, compiled.bundle);
-    assert!(reopened.decoded.migration.is_none());
-    assert_eq!(compiled.diagnostics.len(), 2);
+    assert_eq!(
+        compiled.bundle, input,
+        "every example identity is already explicit"
+    );
     assert!(
-        compiled
-            .diagnostics
-            .iter()
-            .all(|issue| issue.diagnostic.code == "unspecified_exchange_mechanism"),
+        compiled.diagnostics.is_empty(),
         "{:?}",
         compiled.diagnostics
     );
@@ -495,15 +473,7 @@ fn checked_in_example_supports_cross_file_reparent_without_changing_allocations(
         ProjectLimits::default(),
     )
     .unwrap();
-    assert_eq!(result.diagnostics.len(), 2);
-    assert!(
-        result
-            .diagnostics
-            .iter()
-            .all(|issue| issue.diagnostic.code == "unspecified_exchange_mechanism"),
-        "{:?}",
-        result.diagnostics
-    );
+    assert!(result.diagnostics.is_empty(), "{:?}", result.diagnostics);
     assert_eq!(
         result.index.declarations[&assess].path,
         "sa/assurance.arcadia"
@@ -530,6 +500,6 @@ fn checked_in_example_supports_cross_file_reparent_without_changing_allocations(
         "sa/participants.arcadia",
         "views.arcadia",
     ] {
-        assert_eq!(result.bundle.files[path], compiled.bundle.files[path]);
+        assert_eq!(result.bundle.files[path], input.files[path]);
     }
 }

crates/oa-core/src/lib.rs

@@ -1,5 +1,4 @@
 //! Framework-independent OA/SA model, transactional commands and editing services.
-pub mod data;
 pub mod language;
 pub mod model;
 pub mod persistence;
@@ -7,7 +6,6 @@ pub mod ports;
 pub mod projection;
 pub mod references;
 pub mod routing;
-pub mod semantic;
 pub mod session;
 pub mod source_files;
 pub mod source_project;
@@ -15,7 +13,6 @@ pub mod transitions;
 pub mod validation;
 pub use model::*;
 pub use ports::*;
-pub use semantic::*;
 pub use session::*;
 mod demo;
 mod state_validation;

crates/oa-core/src/migration_v2/README.md

@@ -11,14 +11,10 @@ but constructs and validates the frozen DTO, preserves located old-contract
 errors, then calls `adapter.rs`. Original staged scenario/state defaults and
 generic port/optional FE endpoint contracts therefore remain explicit.
 
-`adapter.rs` budgets generated data, validates V2 and transforms only the changed
-port/endpoint payloads into an explicit schema 3 candidate. The schema 3 reader
-then performs the data-contract upgrade into the strict schema 4 envelope. The
-schema 4 review adapter preserves its prose-only trace baselines and returns
-schema 5 with semantic review absent. Serialization
-between compatibility DTOs copies unchanged fields; original input bytes are
-never deserialized into the new `Project`. V1 normalization also constructs this
-V2 DTO before the shared stages. Combined generation stays within one budget.
+`adapter.rs` budgets generated data, validates V2, transforms only the changed
+payloads, and validates schema 3. Serialization between the two typed DTOs copies
+unchanged fields; original input bytes are never deserialized into the new
+`Project`. V1 normalization also constructs this V2 DTO before the shared stage.
 
 Do not update these frozen shapes when extending the current model. Add another
 versioned migration when the persistent contract changes again. Golden V2

crates/oa-core/src/migration_v2/adapter.rs

@@ -62,9 +62,16 @@ pub(crate) fn migrate(
             }],
         });
     }
-    let mut report = MigrationReport::data_upgrade(2);
+    let mut report = MigrationReport {
+        from_schema: 2,
+        to_schema: 3,
+        preserved_ports: vec![],
+        generated_endpoints: vec![],
+        orientation_defaults: vec![],
+        required_resolutions: vec![],
+    };
     let mut value = serde_json::to_value(&old)?;
-    value["schema_version"] = Value::from(3);
+    value["schema_version"] = Value::from(SCHEMA_VERSION);
     for element in old.elements.values() {
         if let Some(super::model::SharedBody::Port {
             direction,
@@ -197,23 +204,11 @@ pub(crate) fn migrate(
             _ => {}
         }
     }
-    // Carry the endpoint-generation reference charge into the next migration;
-    // independent per-stage checks would undercount the combined generated graph.
-    let data_limits = ParseLimits {
-        max_step_references: limits
-            .max_step_references
-            .saturating_sub(additional_references),
-        ..limits
-    };
-    let migrated = super::super::v3::migrate(serde_json::from_value(value)?, data_limits)?;
-    let data = migrated
-        .migration
-        .expect("the schema3 adapter reports its defaults");
-    report.semantic_defaults = data.semantic_defaults;
-    report.generated_interface_allocations = data.generated_interface_allocations;
-    report.unresolved_message_values = data.unresolved_message_values;
+    let project: Project = serde_json::from_value(value)?;
+    limits.check_model(&project).map_err(FileError::Limit)?;
+    super::super::validate_project(&project)?;
     Ok(DecodeResult {
-        project: migrated.project,
+        project,
         migration: Some(report),
     })
 }

crates/oa-core/src/migration_v3/README.md

@@ -1,33 +0,0 @@
-# Schema 3 to 4 reader
-
-Schema 3 is a real compatibility input. Its shapes were frozen at `5ce3eef`.
-The small DTOs in `mod.rs` own the changed data payloads and old message values;
-closed element/relation constructor lists prevent new vocabulary from entering
-the old reader. Unchanged ports, diagram placements/routes, artifacts and traces
-reuse their typed records. The intermediate JSON bridge rejects duplicate keys.
-
-Nature, bounded types, field defaults/direction/storage, and single supertypes
-receive explicit documented defaults. Interface lists become identified ordered
-allocations with UUID v5 namespace equal to the project UUID and name
-`v2-interface-item:<interface-uuid>:<item-uuid>`. The name remains the same for
-V2 and V3 inputs so the migration route cannot change the generated identity.
-Existing IDs never move; deterministic collisions fail with a located diagnostic.
-Aliases use the normal deterministic collision suffix. Unique legacy message
-paths are qualified; ambiguous annotations retain their expression and warning.
-
-V1 first normalizes to the frozen V2 DTO. V2 port/endpoint normalization emits
-an explicit schema3 candidate and then runs this reader before current decoding.
-Generated object, record and reference budgets cover the combined stages.
-
-`language::resolve_declarations` shares lexical/AST parsing, including nesting,
-but chooses frozen source3 payload defaults and rejects new constructors. Both
-single-file parsing and `source_project::compile_bundle` take this explicit path.
-The bundle compiler first stabilizes omitted IDs, then performs targeted token
-edits in `source_project/source_migration.rs`. Original files, includes, lexical
-ownership and comments survive. New allocation declarations stay in the source
-interface's module. The returned source and index describe schema4 bytes; loading
-does not rewrite original disk files. Canonical output and second-save stability
-are schema4. No whole-project formatting fallback handles authored source3.
-
-Frozen source/JSON fixtures live under `tests/fixtures/v3-data-contract.*`; the
-original V2 golden files remain unchanged.

crates/oa-core/src/migration_v3/mod.rs

@@ -1,632 +0,0 @@
-//! Explicit schema-3 compatibility. Only changed payloads are frozen here;
-//! unchanged typed records are shared after a closed old-constructor check.
-use crate::language::ParseLimits;
-use crate::persistence::{DecodeResult, FileError, MigrationReport};
-use crate::*;
-use serde::{Deserialize, Serialize};
-use serde_json::{Value, json};
-use std::collections::{BTreeMap, BTreeSet};
-
-#[derive(Deserialize, Serialize)]
-#[serde(deny_unknown_fields)]
-pub(crate) struct Project3 {
-    pub schema_version: u32,
-    pub id: Id,
-    pub alias: String,
-    pub name: String,
-    pub description: String,
-    #[serde(deserialize_with = "crate::unique_id_map")]
-    pub elements: BTreeMap<Id, Element3>,
-    #[serde(deserialize_with = "crate::unique_id_map")]
-    pub relations: BTreeMap<Id, Relation3>,
-    #[serde(deserialize_with = "crate::unique_id_map")]
-    pub diagrams: BTreeMap<Id, Diagram>,
-    #[serde(deserialize_with = "crate::unique_id_map")]
-    pub artifact_links: BTreeMap<Id, ArtifactLink>,
-    #[serde(deserialize_with = "crate::unique_id_map")]
-    pub traces: BTreeMap<Id, crate::persistence::v4::Trace4>,
-}
-#[derive(Deserialize, Serialize)]
-#[serde(deny_unknown_fields)]
-pub(crate) struct Element3 {
-    pub id: Id,
-    pub alias: String,
-    pub name: String,
-    pub description: String,
-    pub parent: Option<Id>,
-    #[serde(deserialize_with = "strict_value")]
-    pub body: Value,
-}
-#[derive(Deserialize, Serialize)]
-#[serde(deny_unknown_fields)]
-pub(crate) struct Relation3 {
-    pub id: Id,
-    pub alias: String,
-    pub name: String,
-    pub description: String,
-    #[serde(deserialize_with = "strict_value")]
-    pub body: Value,
-}
-
-// A Value bridge must retain the strict duplicate-field behavior of typed DTOs.
-fn strict_value<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Value, D::Error> {
-    struct Strict;
-    impl<'de> serde::de::Visitor<'de> for Strict {
-        type Value = Value;
-        fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            f.write_str("a value with unique object fields")
-        }
-        fn visit_bool<E: serde::de::Error>(self, v: bool) -> Result<Value, E> {
-            Ok(v.into())
-        }
-        fn visit_i64<E: serde::de::Error>(self, v: i64) -> Result<Value, E> {
-            Ok(v.into())
-        }
-        fn visit_u64<E: serde::de::Error>(self, v: u64) -> Result<Value, E> {
-            Ok(v.into())
-        }
-        fn visit_f64<E: serde::de::Error>(self, v: f64) -> Result<Value, E> {
-            serde_json::Number::from_f64(v)
-                .map(Value::Number)
-                .ok_or_else(|| E::custom("Non-finite number"))
-        }
-        fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Value, E> {
-            Ok(v.into())
-        }
-        fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Value, E> {
-            Ok(v.into())
-        }
-        fn visit_unit<E: serde::de::Error>(self) -> Result<Value, E> {
-            Ok(Value::Null)
-        }
-        fn visit_none<E: serde::de::Error>(self) -> Result<Value, E> {
-            Ok(Value::Null)
-        }
-        fn visit_seq<A: serde::de::SeqAccess<'de>>(self, mut a: A) -> Result<Value, A::Error> {
-            let mut out = Vec::new();
-            while let Some(v) = a.next_element::<StrictValue>()? {
-                out.push(v.0);
-            }
-            Ok(Value::Array(out))
-        }
-        fn visit_map<A: serde::de::MapAccess<'de>>(self, mut a: A) -> Result<Value, A::Error> {
-            let mut out = serde_json::Map::new();
-            while let Some((k, v)) = a.next_entry::<String, StrictValue>()? {
-                if out.insert(k.clone(), v.0).is_some() {
-                    return Err(serde::de::Error::custom(format!("Duplicate field '{k}'")));
-                }
-            }
-            Ok(Value::Object(out))
-        }
-    }
-    d.deserialize_any(Strict)
-}
-struct StrictValue(Value);
-impl<'de> Deserialize<'de> for StrictValue {
-    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-        strict_value(d).map(Self)
-    }
-}
-
-#[derive(Deserialize)]
-enum ItemKind3 {
-    Information,
-    Material,
-    Energy,
-    Event,
-}
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-enum Definition3 {
-    Boolean,
-    Integer,
-    Real,
-    String,
-    Enumeration { literals: Vec<String> },
-    Record,
-}
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-struct Item3 {
-    kind: ItemKind3,
-}
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-struct Type3 {
-    definition: Definition3,
-}
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-struct Field3 {
-    type_ref: TypeRef,
-    minimum: u32,
-    maximum: Option<u32>,
-    unit: String,
-}
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-struct Interface3 {
-    items: Vec<Id>,
-}
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-struct MessageValue3 {
-    field: Id,
-    expression: String,
-}
-
-pub(crate) fn relation_allowed(name: &str) -> bool {
-    matches!(
-        name,
-        "Allocation"
-            | "PortAllocation"
-            | "Interaction"
-            | "CapabilityInvolvement"
-            | "ChainInvolvement"
-            | "RoleRealization"
-            | "RoleAssignment"
-            | "FunctionalExchange"
-            | "BoundaryExchange"
-            | "MissionCapability"
-            | "CapabilityInclude"
-            | "CapabilityExtend"
-            | "CapabilityGeneralization"
-            | "MissionInvolvement"
-            | "SequenceLink"
-            | "StateTransition"
-            | "Availability"
-            | "ExchangeAllocation"
-            | "InterfaceProvision"
-            | "InterfaceRequirement"
-            | "StateAction"
-    )
-}
-pub(crate) fn element_allowed(name: &str) -> bool {
-    matches!(
-        name,
-        "Entity"
-            | "Actor"
-            | "Role"
-            | "Activity"
-            | "Capability"
-            | "OperationalMission"
-            | "Process"
-            | "System"
-            | "SystemActor"
-            | "Function"
-            | "SystemCapability"
-            | "Mission"
-            | "FunctionalChain"
-            | "ExchangeItem"
-            | "DataType"
-            | "DataField"
-            | "Interface"
-            | "Port"
-            | "Scenario"
-            | "Lifeline"
-            | "Occurrence"
-            | "StateMachine"
-            | "Region"
-            | "State"
-            | "Mode"
-            | "Initial"
-            | "Final"
-            | "Choice"
-            | "Junction"
-            | "Fork"
-            | "Join"
-            | "ShallowHistory"
-            | "DeepHistory"
-            | "EntryPoint"
-            | "ExitPoint"
-            | "Terminate"
-            | "Event"
-            | "Constraint"
-    )
-}
-pub(crate) fn legacy_defaults(kind: Kind) -> Option<Value> {
-    Some(match kind {
-        Kind::ExchangeItem => json!({"kind":"Information"}),
-        Kind::DataType => json!({"definition":"String"}),
-        Kind::DataField => json!({"type_ref":"String","minimum":1,"maximum":1,"unit":""}),
-        Kind::Interface => json!({"items":[]}),
-        _ => return None,
-    })
-}
-
-fn at(id: Id, field: &str, code: &str, message: impl Into<String>) -> FileError {
-    let message = message.into();
-    FileError::Model {
-        message: format!("V3 {code} at {id}.{field}: {message}"),
-        issues: vec![validation::Issue {
-            severity: validation::Severity::Error,
-            element: Some(id),
-            code: code.into(),
-            field: Some(field.into()),
-            message,
-        }],
-    }
-}
-fn singleton(value: &Value) -> Option<(&str, &Value)> {
-    let object = value.as_object()?;
-    (object.len() == 1)
-        .then(|| object.iter().next().unwrap())
-        .map(|(k, v)| (k.as_str(), v))
-}
-fn old_payload<T: serde::de::DeserializeOwned>(
-    id: Id,
-    field: &str,
-    value: Value,
-) -> Result<T, FileError> {
-    serde_json::from_value(value).map_err(|error| at(id, field, "legacy_shape", error.to_string()))
-}
-
-pub(crate) fn migrate(old: Project3, limits: ParseLimits) -> Result<DecodeResult, FileError> {
-    if old.schema_version != 3 {
-        return Err(FileError::Invalid("Expected schema_version 3.".into()));
-    }
-    let graph = old.elements.len().saturating_add(old.relations.len());
-    let records = graph
-        .saturating_add(old.diagrams.len())
-        .saturating_add(old.diagrams.values().map(|d| d.nodes.len()).sum::<usize>())
-        .saturating_add(old.traces.len())
-        .saturating_add(old.artifact_links.len())
-        .saturating_add(1);
-    limits
-        .check_counts(graph, records, 0)
-        .map_err(FileError::Limit)?;
-    let mut report = MigrationReport::data_upgrade(3);
-    let mut value = serde_json::to_value(&old)?;
-    let mut allocations = Vec::new();
-    for (key, e) in &old.elements {
-        if *key != e.id {
-            return Err(at(
-                e.id,
-                "id",
-                "identity",
-                "Element map key differs from its identity.",
-            ));
-        }
-        let mut body = e.body.clone();
-        let (layer, inner) = singleton(&body)
-            .filter(|(name, _)| matches!(*name, "Oa" | "Sa"))
-            .ok_or_else(|| {
-                at(
-                    e.id,
-                    "body",
-                    "legacy_shape",
-                    "Expected one OA or SA constructor.",
-                )
-            })?;
-        let layer = layer.to_owned();
-        let outer = inner
-            .as_str()
-            .or_else(|| singleton(inner).map(|(name, _)| name));
-        if !outer.is_some_and(|name| {
-            if layer == "Oa" {
-                matches!(
-                    name,
-                    "Entity"
-                        | "Actor"
-                        | "Role"
-                        | "Activity"
-                        | "Capability"
-                        | "Mission"
-                        | "Process"
-                        | "Shared"
-                )
-            } else {
-                matches!(
-                    name,
-                    "System"
-                        | "Actor"
-                        | "Function"
-                        | "Capability"
-                        | "Mission"
-                        | "FunctionalChain"
-                        | "Shared"
-                )
-            }
-        }) {
-            return Err(at(
-                e.id,
-                "body",
-                "legacy_shape",
-                "Unknown schema3 layer constructor.",
-            ));
-        }
-        if let Some(("Shared", shared)) = singleton(inner) {
-            let name = shared
-                .as_str()
-                .or_else(|| singleton(shared).map(|(name, _)| name))
-                .ok_or_else(|| {
-                    at(
-                        e.id,
-                        "body",
-                        "legacy_shape",
-                        "Expected one schema3 shared constructor.",
-                    )
-                })?
-                .to_owned();
-            if !matches!(
-                name.as_str(),
-                "ExchangeItem"
-                    | "DataType"
-                    | "DataField"
-                    | "Interface"
-                    | "Port"
-                    | "Scenario"
-                    | "Lifeline"
-                    | "Occurrence"
-                    | "StateMachine"
-                    | "Event"
-                    | "Region"
-                    | "State"
-                    | "Constraint"
-            ) {
-                return Err(at(
-                    e.id,
-                    "body",
-                    "legacy_shape",
-                    format!("Unknown schema3 shared constructor '{name}'."),
-                ));
-            }
-            let payload = shared.get(&name).cloned().unwrap_or(Value::Null);
-            let changed = match name.as_str() {
-                "ExchangeItem" => {
-                    let old: Item3 = old_payload(e.id, "body.kind", payload)?;
-                    let (kind, mechanism) = match old.kind {
-                        ItemKind3::Information => ("Information", "Unspecified"),
-                        ItemKind3::Material => ("Material", "Unspecified"),
-                        ItemKind3::Energy => ("Energy", "Unspecified"),
-                        ItemKind3::Event => ("Information", "Event"),
-                    };
-                    Some(json!({"kind":kind,"mechanism":mechanism,"supertype":null}))
-                }
-                "DataType" => {
-                    let old: Type3 = old_payload(e.id, "body.definition", payload)?;
-                    let definition = match old.definition {
-                        Definition3::Boolean => json!("Boolean"),
-                        Definition3::Integer => json!({"Integer":{"minimum":null,"maximum":null}}),
-                        Definition3::Real => json!({"Real":{"minimum":null,"maximum":null}}),
-                        Definition3::String => {
-                            json!({"String":{"minimum_length":0,"maximum_length":null}})
-                        }
-                        Definition3::Enumeration { literals } => {
-                            json!({"Enumeration":{"literals":literals}})
-                        }
-                        Definition3::Record => json!({"Record":{"supertype":null}}),
-                    };
-                    Some(json!({"definition":definition,"default":null,"unit":""}))
-                }
-                "DataField" => {
-                    let old: Field3 = old_payload(e.id, "body", payload)?;
-                    Some(
-                        json!({"type_ref":old.type_ref,"minimum":old.minimum,"maximum":old.maximum,"unit":old.unit,"direction":"Unspecified","storage":"Value","default":null}),
-                    )
-                }
-                "Interface" => {
-                    let old: Interface3 = old_payload(e.id, "items", payload)?;
-                    let mut seen = BTreeSet::new();
-                    for (order, item) in old.items.into_iter().enumerate() {
-                        if !seen.insert(item) {
-                            return Err(at(
-                                e.id,
-                                "items",
-                                "duplicate_reference",
-                                "Interface items must be unique.",
-                            ));
-                        }
-                        allocations.push((e.id, item, order));
-                    }
-                    Some(json!({"supertype":null}))
-                }
-                "Occurrence" => {
-                    let mut payload = payload;
-                    if let Some(values) = payload.pointer_mut("/body/Exchange/values") {
-                        let old: Vec<MessageValue3> =
-                            old_payload(e.id, "body.values", values.clone())?;
-                        *values=Value::Array(old.into_iter().map(|v|json!({"field":v.field,"expression":v.expression,"path":[]})).collect());
-                    }
-                    Some(payload)
-                }
-                _ => None,
-            };
-            if let Some(changed) = changed {
-                let description = match name.as_str() {
-                    "ExchangeItem" if changed["mechanism"] == "Event" => {
-                        "Legacy Event nature becomes Information with Event mechanism; supertype is absent."
-                    }
-                    "ExchangeItem" => {
-                        "Nature is retained; mechanism is Unspecified and supertype is absent."
-                    }
-                    "DataType" => {
-                        "Existing type is retained with unbounded numeric/string limits, no scalar default or unit, and no Record supertype."
-                    }
-                    "DataField" => {
-                        "Type, ownership, multiplicity and unit are retained; direction is Unspecified, storage is Value and default is absent."
-                    }
-                    "Interface" => {
-                        "Items become identified ordered allocations with Unspecified protocols; supertype is absent."
-                    }
-                    _ => {
-                        "Value expressions are retained; unique enclosing field paths are resolved and ambiguous legacy paths remain unresolved."
-                    }
-                };
-                body[&layer]["Shared"][&name] = changed;
-                report
-                    .semantic_defaults
-                    .push(crate::persistence::SemanticDefault {
-                        object: e.id,
-                        field: "body".into(),
-                        description: description.into(),
-                    });
-            }
-        }
-        // Current deserialization checks the reused, unchanged outer/typed parts.
-        let _: ElementBody = serde_json::from_value(body.clone())
-            .map_err(|error| at(e.id, "body", "legacy_shape", error.to_string()))?;
-        value["elements"][key.to_string()]["body"] = body;
-    }
-    for (key, r) in &old.relations {
-        if *key != r.id {
-            return Err(at(
-                r.id,
-                "id",
-                "identity",
-                "Relation map key differs from its identity.",
-            ));
-        }
-        if !singleton(&r.body).is_some_and(|(name, _)| relation_allowed(name)) {
-            return Err(at(
-                r.id,
-                "body",
-                "legacy_shape",
-                "Relation constructor was not part of schema3.",
-            ));
-        }
-    }
-    value["schema_version"] = 4.into();
-    let normalized: crate::persistence::v4::Project4 = serde_json::from_value(value)?;
-    let mut project = normalized.into_current()?;
-    crate::persistence::v4::review_defaults(&project, &mut report);
-    let mut references = project
-        .elements
-        .values()
-        .map(|e| e.steps().map_or(0, Vec::len))
-        .sum::<usize>()
-        .saturating_add(allocations.len().saturating_mul(2));
-    limits
-        .check_counts(
-            project
-                .elements
-                .len()
-                .saturating_add(project.relations.len())
-                .saturating_add(allocations.len()),
-            project.identities().len().saturating_add(allocations.len()),
-            references,
-        )
-        .map_err(FileError::Limit)?;
-    let mut ids: BTreeSet<_> = project.identities().into_iter().map(|(id, _)| id).collect();
-    for (source, target, order) in allocations {
-        let id = Id::new_v5(
-            &project.id,
-            format!("v2-interface-item:{source}:{target}").as_bytes(),
-        );
-        if !ids.insert(id) {
-            return Err(at(
-                source,
-                "items",
-                "identity_collision",
-                format!(
-                    "Deterministic interface allocation {id} already belongs to another object."
-                ),
-            ));
-        }
-        let name = format!("{} · {}", project.named(source), project.named(target));
-        let alias = project.fresh_alias(
-            &format!(
-                "{}_{}_allocation",
-                project
-                    .elements
-                    .get(&source)
-                    .map_or("interface", |e| e.alias.as_str()),
-                project
-                    .elements
-                    .get(&target)
-                    .map_or("item", |e| e.alias.as_str())
-            ),
-            "interface_item_allocation",
-            id,
-        );
-        project.relations.insert(
-            id,
-            Relation {
-                id,
-                alias: alias.clone(),
-                name,
-                description: String::new(),
-                body: RelationBody::InterfaceItemAllocation {
-                    source,
-                    target,
-                    order: order.try_into().map_err(|_| {
-                        at(source, "items", "model_limit", "Too many interface items.")
-                    })?,
-                    transmission: TransmissionProtocol::Unspecified,
-                    acquisition: AcquisitionProtocol::Unspecified,
-                },
-            },
-        );
-        report.generated_interface_allocations.push(
-            crate::persistence::GeneratedInterfaceAllocation {
-                id,
-                source,
-                target,
-                alias,
-                order: order as u32,
-            },
-        );
-    }
-    let annotations: Vec<_> = project
-        .elements
-        .values()
-        .filter_map(|e| match e.shared() {
-            Some(SharedBody::Occurrence {
-                body:
-                    OccurrenceBody::Exchange {
-                        exchange: Some(exchange),
-                        values,
-                        ..
-                    },
-                ..
-            }) => Some((e.id, *exchange, values.clone())),
-            _ => None,
-        })
-        .collect();
-    for (owner, exchange, values) in annotations {
-        let Some(relation) = project.relations.get(&exchange) else {
-            continue;
-        };
-        for (index, value) in values.into_iter().enumerate() {
-            let resolution =
-                crate::data::resolve_legacy_field_path(&project, relation, value.field)
-                    .map_err(|message| at(owner, "body.values", "model_limit", message))?;
-            if let crate::data::LegacyFieldPathResolution::Unique(path) = resolution {
-                if !path.is_empty() {
-                    references = references.saturating_add(path.len());
-                    limits
-                        .check_counts(
-                            project
-                                .elements
-                                .len()
-                                .saturating_add(project.relations.len()),
-                            project.identities().len(),
-                            references,
-                        )
-                        .map_err(FileError::Limit)?;
-                    if let Some(SharedBody::Occurrence {
-                        body: OccurrenceBody::Exchange { values, .. },
-                        ..
-                    }) = project
-                        .elements
-                        .get_mut(&owner)
-                        .and_then(Element::shared_mut)
-                    {
-                        values[index].path = path;
-                    }
-                }
-            } else if matches!(
-                resolution,
-                crate::data::LegacyFieldPathResolution::Ambiguous
-            ) {
-                report.unresolved_message_values.push(crate::persistence::UnresolvedMessageValue { occurrence:owner,field:value.field,reason:"Several carried paths reach this legacy field; choose an explicit argument path.".into() });
-            }
-        }
-    }
-    limits.check_model(&project).map_err(FileError::Limit)?;
-    super::validate_project(&project)?;
-    Ok(DecodeResult {
-        project,
-        migration: Some(report),
-    })
-}

crates/oa-core/src/migration_v4.rs

@@ -1,117 +0,0 @@
-//! Frozen schema4 review envelopes. Other model records are unchanged in schema5.
-use crate::language::ParseLimits;
-use crate::persistence::{DecodeResult, FileError, MigrationReport, SemanticDefault};
-use crate::*;
-use serde::{Deserialize, Serialize};
-use std::collections::BTreeMap;
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub(crate) struct TraceBaseline4 {
-    pub oa: TracedProperties,
-    pub sa: TracedProperties,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub(crate) struct Trace4 {
-    pub id: Id,
-    pub alias: String,
-    pub name: String,
-    pub description: String,
-    pub oa: Id,
-    pub sa: Id,
-    pub kind: TraceKind,
-    pub baseline: Option<TraceBaseline4>,
-}
-impl From<Trace4> for Trace {
-    fn from(old: Trace4) -> Self {
-        Self {
-            id: old.id,
-            alias: old.alias,
-            name: old.name,
-            description: old.description,
-            oa: old.oa,
-            sa: old.sa,
-            kind: old.kind,
-            baseline: old.baseline.map(|baseline| TraceBaseline {
-                oa: baseline.oa,
-                sa: baseline.sa,
-                semantic: None,
-            }),
-        }
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-pub(crate) struct Project4 {
-    pub schema_version: u32,
-    pub id: Id,
-    pub alias: String,
-    pub name: String,
-    pub description: String,
-    #[serde(deserialize_with = "crate::unique_id_map")]
-    pub elements: BTreeMap<Id, Element>,
-    #[serde(deserialize_with = "crate::unique_id_map")]
-    pub relations: BTreeMap<Id, Relation>,
-    #[serde(deserialize_with = "crate::unique_id_map")]
-    pub diagrams: BTreeMap<Id, Diagram>,
-    #[serde(deserialize_with = "crate::unique_id_map")]
-    pub artifact_links: BTreeMap<Id, ArtifactLink>,
-    #[serde(deserialize_with = "crate::unique_id_map")]
-    pub traces: BTreeMap<Id, Trace4>,
-}
-impl Project4 {
-    pub(crate) fn into_current(self) -> Result<Project, FileError> {
-        if self.schema_version != 4 {
-            return Err(FileError::Invalid("Expected schema_version 4.".into()));
-        }
-        Ok(Project {
-            schema_version: SCHEMA_VERSION,
-            id: self.id,
-            alias: self.alias,
-            name: self.name,
-            description: self.description,
-            elements: self.elements,
-            relations: self.relations,
-            diagrams: self.diagrams,
-            artifact_links: self.artifact_links,
-            traces: self
-                .traces
-                .into_iter()
-                .map(|(id, trace)| (id, trace.into()))
-                .collect(),
-        })
-    }
-}
-
-pub(crate) fn review_defaults(project: &Project, report: &mut MigrationReport) {
-    report.semantic_defaults.extend(
-        project
-            .traces
-            .values()
-            .filter(|trace| trace.baseline.is_some())
-            .map(|trace| SemanticDefault {
-                object: trace.id,
-                field: "baseline.semantic".into(),
-                description: "Original prose review preserved; semantic facets remain unreviewed."
-                    .into(),
-            }),
-    );
-}
-
-pub(crate) fn finish(mut project: Project, limits: ParseLimits) -> Result<DecodeResult, FileError> {
-    project.schema_version = SCHEMA_VERSION;
-    limits.check_model(&project).map_err(FileError::Limit)?;
-    let mut report = MigrationReport::data_upgrade(4);
-    review_defaults(&project, &mut report);
-    Ok(DecodeResult {
-        project,
-        migration: Some(report),
-    })
-}
-
-pub(crate) fn migrate(old: Project4, limits: ParseLimits) -> Result<DecodeResult, FileError> {
-    finish(old.into_current()?, limits)
-}

crates/oa-core/src/model.rs

@@ -6,7 +6,7 @@ use std::{
 use uuid::Uuid;
 
 pub type Id = Uuid;
-pub const SCHEMA_VERSION: u32 = 5;
+pub const SCHEMA_VERSION: u32 = 3;
 pub const MAX_COORDINATE: f32 = 1_000_000.;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
@@ -265,79 +265,17 @@ pub enum ExchangeItemKind {
     Information,
     Material,
     Energy,
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub enum ExchangeMechanism {
-    #[default]
-    Unspecified,
-    Flow,
     Event,
-    Operation,
-    SharedData,
 }
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub enum ParameterDirection {
-    #[default]
-    Unspecified,
-    In,
-    Out,
-    InOut,
-    Return,
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub enum FieldStorage {
-    #[default]
-    Value,
-    Reference,
-}
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub enum DataValue {
-    Boolean(bool),
-    Integer(i64),
-    Real(f64),
-    String(String),
-    Enumeration(String),
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub enum TransmissionProtocol {
-    #[default]
-    Unspecified,
-    Synchronous,
-    Asynchronous,
-    Unicast,
-    Multicast,
-    Broadcast,
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub enum AcquisitionProtocol {
-    #[default]
-    Unspecified,
-    Read,
-    Accept,
-}
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub enum DataTypeDefinition {
     Boolean,
-    Integer {
-        minimum: Option<i64>,
-        maximum: Option<i64>,
-    },
-    Real {
-        minimum: Option<f64>,
-        maximum: Option<f64>,
-    },
-    String {
-        minimum_length: u32,
-        maximum_length: Option<u32>,
-    },
-    Enumeration {
-        literals: Vec<String>,
-    },
-    Record {
-        supertype: Option<Id>,
-    },
+    Integer,
+    Real,
+    String,
+    Enumeration { literals: Vec<String> },
+    Record,
 }
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
@@ -515,8 +453,6 @@ pub struct LifelineBinding {
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct MessageValue {
-    #[serde(default)]
-    pub path: Vec<Id>,
     pub field: Id,
     pub expression: String,
 }
@@ -566,25 +502,18 @@ pub enum OccurrenceBody {
 pub enum SharedBody {
     ExchangeItem {
         kind: ExchangeItemKind,
-        mechanism: ExchangeMechanism,
-        supertype: Option<Id>,
     },
     DataType {
         definition: DataTypeDefinition,
-        default: Option<DataValue>,
-        unit: String,
     },
     DataField {
         type_ref: TypeRef,
         minimum: u32,
         maximum: Option<u32>,
         unit: String,
-        direction: ParameterDirection,
-        storage: FieldStorage,
-        default: Option<Vec<DataValue>>,
     },
     Interface {
-        supertype: Option<Id>,
+        items: Vec<Id>,
     },
     Port {
         contract: PortContract,
@@ -743,27 +672,17 @@ impl ElementBody {
                 match k {
                     Kind::ExchangeItem => SharedBody::ExchangeItem {
                         kind: ExchangeItemKind::Information,
-                        mechanism: ExchangeMechanism::Unspecified,
-                        supertype: None,
                     },
                     Kind::DataType => SharedBody::DataType {
-                        definition: DataTypeDefinition::String {
-                            minimum_length: 0,
-                            maximum_length: None,
-                        },
-                        default: None,
-                        unit: String::new(),
+                        definition: DataTypeDefinition::String,
                     },
                     Kind::DataField => SharedBody::DataField {
                         type_ref: TypeRef::String,
                         minimum: 1,
                         maximum: Some(1),
                         unit: String::new(),
-                        direction: ParameterDirection::Unspecified,
-                        storage: FieldStorage::Value,
-                        default: None,
                     },
-                    Kind::Interface => SharedBody::Interface { supertype: None },
+                    Kind::Interface => SharedBody::Interface { items: vec![] },
                     // Port creation requires an explicit contract and owner.
                     Kind::Port => return None,
                     Kind::Scenario => SharedBody::Scenario {
@@ -833,8 +752,6 @@ impl SharedBody {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub enum RelationKind {
-    InterfaceItemAllocation,
-    DataAssociation,
     Allocation,
     PortAllocation,
     Interaction,
@@ -858,9 +775,7 @@ pub enum RelationKind {
     StateAction,
 }
 impl RelationKind {
-    pub const ALL: [Self; 23] = [
-        Self::InterfaceItemAllocation,
-        Self::DataAssociation,
+    pub const ALL: [Self; 21] = [
         Self::Allocation,
         Self::PortAllocation,
         Self::Interaction,
@@ -885,8 +800,6 @@ impl RelationKind {
     ];
     pub fn permits(self, from: Kind, to: Kind) -> bool {
         match self {
-            Self::InterfaceItemAllocation => from == Kind::Interface && to == Kind::ExchangeItem,
-            Self::DataAssociation => from == Kind::DataType && to == Kind::DataType,
             Self::Allocation => from.is_performer() && to.is_work(),
             Self::PortAllocation => from == Kind::Port && to == Kind::Port,
             Self::Interaction => from == Kind::Activity && to == Kind::Activity,
@@ -942,8 +855,6 @@ impl RelationKind {
     }
     pub fn hint(self) -> &'static str {
         match self {
-            Self::InterfaceItemAllocation => "Interface → allocated exchange item",
-            Self::DataAssociation => "Record type → record type",
             Self::Allocation => "Performer → leaf activity/function",
             Self::PortAllocation => "Component port → allocated function port",
             Self::Interaction => "OA activity → OA activity",
@@ -975,8 +886,6 @@ impl RelationKind {
 impl fmt::Display for RelationKind {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(match self {
-            Self::InterfaceItemAllocation => "Interface item allocation",
-            Self::DataAssociation => "Data association",
             Self::Allocation => "Allocation",
             Self::PortAllocation => "Port allocation",
             Self::Interaction => "Interaction",
@@ -1013,25 +922,6 @@ pub struct Relation {
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub enum RelationBody {
-    InterfaceItemAllocation {
-        source: Id,
-        target: Id,
-        order: u32,
-        transmission: TransmissionProtocol,
-        acquisition: AcquisitionProtocol,
-    },
-    DataAssociation {
-        source: Id,
-        target: Id,
-        source_role: String,
-        target_role: String,
-        source_minimum: u32,
-        source_maximum: Option<u32>,
-        target_minimum: u32,
-        target_maximum: Option<u32>,
-        source_navigable: bool,
-        target_navigable: bool,
-    },
     Allocation {
         source: Id,
         target: Id,
@@ -1149,8 +1039,6 @@ impl Relation {
 impl RelationBody {
     pub fn kind(&self) -> RelationKind {
         match self {
-            Self::InterfaceItemAllocation { .. } => RelationKind::InterfaceItemAllocation,
-            Self::DataAssociation { .. } => RelationKind::DataAssociation,
             Self::Allocation { .. } => RelationKind::Allocation,
             Self::PortAllocation { .. } => RelationKind::PortAllocation,
             Self::Interaction { .. } => RelationKind::Interaction,
@@ -1176,9 +1064,7 @@ impl RelationBody {
     }
     pub fn endpoints(&self) -> (Id, Id) {
         match self {
-            Self::InterfaceItemAllocation { source, target, .. }
-            | Self::DataAssociation { source, target, .. }
-            | Self::Allocation { source, target }
+            Self::Allocation { source, target }
             | Self::PortAllocation { source, target }
             | Self::Interaction { source, target, .. }
             | Self::CapabilityInvolvement { source, target }
@@ -1203,9 +1089,7 @@ impl RelationBody {
     }
     pub fn set_endpoints(&mut self, a: Id, b: Id) {
         match self {
-            Self::InterfaceItemAllocation { source, target, .. }
-            | Self::DataAssociation { source, target, .. }
-            | Self::Allocation { source, target }
+            Self::Allocation { source, target }
             | Self::PortAllocation { source, target }
             | Self::Interaction { source, target, .. }
             | Self::CapabilityInvolvement { source, target }
@@ -1241,25 +1125,6 @@ impl RelationBody {
     }
     pub fn new(kind: RelationKind, source: Id, target: Id) -> Self {
         match kind {
-            RelationKind::InterfaceItemAllocation => Self::InterfaceItemAllocation {
-                source,
-                target,
-                order: 0,
-                transmission: TransmissionProtocol::Unspecified,
-                acquisition: AcquisitionProtocol::Unspecified,
-            },
-            RelationKind::DataAssociation => Self::DataAssociation {
-                source,
-                target,
-                source_role: String::new(),
-                target_role: String::new(),
-                source_minimum: 0,
-                source_maximum: None,
-                target_minimum: 0,
-                target_maximum: None,
-                source_navigable: false,
-                target_navigable: false,
-            },
             RelationKind::Allocation => Self::Allocation { source, target },
             RelationKind::PortAllocation => Self::PortAllocation { source, target },
             RelationKind::Interaction => Self::Interaction {
@@ -1492,15 +1357,13 @@ pub struct TracedProperties {
     pub name: String,
     pub description: String,
 }
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct TraceBaseline {
     pub oa: TracedProperties,
     pub sa: TracedProperties,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub semantic: Option<crate::semantic::SemanticBaseline>,
 }
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct Trace {
     pub id: Id,

crates/oa-core/src/persistence.rs

@@ -5,10 +5,6 @@ use thiserror::Error;
 #[path = "migration_v2/mod.rs"]
 pub(crate) mod v2;
 pub(crate) use v2::adapter::migrate as migrate_v2_limited;
-#[path = "migration_v3/mod.rs"]
-pub(crate) mod v3;
-#[path = "migration_v4.rs"]
-pub(crate) mod v4;
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
@@ -19,50 +15,6 @@ pub struct MigrationReport {
     pub generated_endpoints: Vec<GeneratedEndpoint>,
     pub orientation_defaults: Vec<OrientationDefault>,
     pub required_resolutions: Vec<Id>,
-    #[serde(default)]
-    pub semantic_defaults: Vec<SemanticDefault>,
-    #[serde(default)]
-    pub generated_interface_allocations: Vec<GeneratedInterfaceAllocation>,
-    #[serde(default)]
-    pub unresolved_message_values: Vec<UnresolvedMessageValue>,
-}
-impl MigrationReport {
-    pub(crate) fn data_upgrade(from_schema: u32) -> Self {
-        Self {
-            from_schema,
-            to_schema: SCHEMA_VERSION,
-            preserved_ports: vec![],
-            generated_endpoints: vec![],
-            orientation_defaults: vec![],
-            required_resolutions: vec![],
-            semantic_defaults: vec![],
-            generated_interface_allocations: vec![],
-            unresolved_message_values: vec![],
-        }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct SemanticDefault {
-    pub object: Id,
-    pub field: String,
-    pub description: String,
-}
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct GeneratedInterfaceAllocation {
-    pub id: Id,
-    pub source: Id,
-    pub target: Id,
-    pub alias: String,
-    pub order: u32,
-}
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct UnresolvedMessageValue {
-    pub occurrence: Id,
-    pub field: Id,
-    pub reason: String,
 }
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
@@ -149,15 +101,13 @@ pub fn decode_with_report_limited(
                 migrate_v1_with_report_limited(old, limits)?
             }
             Some(2) => migrate_v2_limited(serde_json::from_slice(bytes)?, limits)?,
-            Some(3) => v3::migrate(serde_json::from_slice(bytes)?, limits)?,
-            Some(4) => v4::migrate(serde_json::from_slice(bytes)?, limits)?,
-            Some(5) => DecodeResult {
+            Some(3) => DecodeResult {
                 project: serde_json::from_slice(bytes)?,
                 migration: None,
             },
             _ => {
                 return Err(FileError::Invalid(
-                    "Unsupported or missing schema_version; expected 1, 2, 3, 4 or 5.".into(),
+                    "Unsupported or missing schema_version; expected 1, 2 or 3.".into(),
                 ));
             }
         }

crates/oa-core/src/ports.rs

@@ -64,9 +64,9 @@ pub struct LegacyWorkPortSplitRequest {
     pub outgoing_items: Vec<Id>,
 }
 
-/// A specialized carried item satisfies a declared base item.
-pub fn item_satisfies(project: &Project, carried: Id, declared: Id) -> bool {
-    crate::data::item_satisfies(project, carried, declared)
+/// R6 specialization has one explicit seam; current models support identity only.
+pub fn item_satisfies(_project: &Project, carried: Id, declared: Id) -> bool {
+    carried == declared
 }
 pub fn items_satisfy(project: &Project, carried: &[Id], declared: &[Id]) -> bool {
     carried.iter().all(|item| {
@@ -130,7 +130,13 @@ fn declared_interface_items(p: &Project, port: Id) -> Option<Vec<Id>> {
     Some(
         interfaces
             .into_iter()
-            .flat_map(|id| crate::data::interface_items(p, id))
+            .filter_map(|id| p.elements.get(&id))
+            .filter_map(|e| match e.shared() {
+                Some(SharedBody::Interface { items }) => Some(items),
+                _ => None,
+            })
+            .flatten()
+            .copied()
             .collect(),
     )
 }
@@ -897,10 +903,14 @@ fn validate_carried_contract(p: &Project, r: &Relation, port: &Element, out: &mu
             ..
         }) => {
             let mut allowed = declared_interface_items(p, port.id);
-            if let Some(interface) = legacy.as_ref().and_then(|l| l.interface) {
-                let items = crate::data::interface_items(p, interface);
+            if let Some(SharedBody::Interface { items }) = legacy
+                .as_ref()
+                .and_then(|l| l.interface)
+                .and_then(|id| p.elements.get(&id))
+                .and_then(Element::shared)
+            {
                 if r.kind() == RelationKind::BoundaryExchange
-                    && !items_satisfy(p, r.body.items(), &items)
+                    && !items_satisfy(p, r.body.items(), items)
                 {
                     error(
                         out,
@@ -1163,7 +1173,7 @@ pub(crate) fn validate_boundary_interface_requirements(
             if !p.relations.values().any(|role| {
                 role.kind() == RelationKind::InterfaceProvision
                     && role.source() == peer.id
-                    && crate::data::interface_satisfies(p, role.target(), required.target())
+                    && role.target() == required.target()
             }) {
                 warning(
                     out,

crates/oa-core/src/projection.rs

@@ -335,11 +335,6 @@ pub fn project_diagram(p: &Project, d: &Diagram) -> ProjectedView {
         .collect();
     let mut edges = Vec::new();
     for r in p.relations.values() {
-        // Interface allocations are selectable nested dictionary rows. Their
-        // independently identified contracts do not add noisy diagram arrows.
-        if r.kind() == RelationKind::InterfaceItemAllocation {
-            continue;
-        }
         if d.projection == ProjectionKind::Allocation && r.kind() == RelationKind::Allocation {
             continue;
         }
@@ -375,8 +370,7 @@ pub fn project_diagram(p: &Project, d: &Diagram) -> ProjectedView {
         }
         if let (Some(source), Some(target)) = (anchor(r.source()), anchor(r.target()))
             && (source != target
-                || ((d.projection.state_machine().is_some()
-                    || r.kind() == RelationKind::DataAssociation)
+                || (d.projection.state_machine().is_some()
                     && r.source() == r.target()
                     && nodes
                         .iter()
@@ -402,7 +396,7 @@ pub fn project_diagram(p: &Project, d: &Diagram) -> ProjectedView {
                     RelationBody::BoundaryExchange {
                         oriented: false,
                         ..
-                    } | RelationBody::DataAssociation { .. }
+                    }
                 ),
                 source_port: source_port.filter(|id| visible_ports.contains(id)),
                 target_port: target_port.filter(|id| visible_ports.contains(id)),

crates/oa-core/src/references.rs

@@ -33,13 +33,8 @@ pub fn visit_element_refs(e: &mut Element, mut visit: impl FnMut(&mut Id)) {
                 type_ref: TypeRef::Named(id),
                 ..
             } => visit(id),
-            SharedBody::Interface { supertype }
-            | SharedBody::ExchangeItem { supertype, .. }
-            | SharedBody::DataType {
-                definition: DataTypeDefinition::Record { supertype },
-                ..
-            } => {
-                if let Some(id) = supertype {
+            SharedBody::Interface { items } => {
+                for id in items {
                     visit(id);
                 }
             }
@@ -88,9 +83,6 @@ pub fn visit_element_refs(e: &mut Element, mut visit: impl FnMut(&mut Id)) {
                         visit(id);
                     }
                     for value in values {
-                        for id in &mut value.path {
-                            visit(id);
-                        }
                         visit(&mut value.field);
                     }
                 }
@@ -222,13 +214,6 @@ pub fn remap_references(p: &mut Project, old: Id, new: Id) {
         if t.sa == old {
             t.sa = new;
         }
-        if let Some(baseline) = t.baseline.as_mut().and_then(|b| b.semantic.as_mut()) {
-            crate::semantic::visit_semantic_references(baseline, |id| {
-                if *id == old {
-                    *id = new;
-                }
-            });
-        }
     }
 }
 /// IDs removed by a cascade. Cross-layer traced counterparts are never included.
@@ -392,12 +377,7 @@ fn remove_objects(p: &mut Project, removed: BTreeSet<Id>) {
         }
         if let Some(shared) = e.shared_mut() {
             match shared {
-                SharedBody::Interface { supertype }
-                | SharedBody::ExchangeItem { supertype, .. }
-                | SharedBody::DataType {
-                    definition: DataTypeDefinition::Record { supertype },
-                    ..
-                } => clear(supertype),
+                SharedBody::Interface { items } => items.retain(|id| !removed.contains(id)),
                 SharedBody::Event {
                     body: EventBody::Signal { items },
                 } => items.retain(|id| !removed.contains(id)),
@@ -433,10 +413,7 @@ fn remove_objects(p: &mut Project, removed: BTreeSet<Id>) {
                         clear(sender);
                         clear(receiver);
                         clear(reply_to);
-                        values.retain(|value| {
-                            !removed.contains(&value.field)
-                                && value.path.iter().all(|id| !removed.contains(id))
-                        });
+                        values.retain(|value| !removed.contains(&value.field));
                     }
                     OccurrenceBody::Action { action, lifeline } => {
                         clear(action);
@@ -508,37 +485,20 @@ fn remove_objects(p: &mut Project, removed: BTreeSet<Id>) {
                         exchange: Some(id), ..
                     },
                 ..
-            }) => p.relations.get(id).map(|r| {
-                let Some(SharedBody::Occurrence {
-                    body: OccurrenceBody::Exchange { values, .. },
-                    ..
-                }) = e.shared()
-                else {
-                    unreachable!()
-                };
-                let retained: Vec<_> = values
-                    .iter()
-                    .filter(|value| {
-                        crate::data::carried_value_path(p, r, &value.path, value.field).is_some()
-                            || (value.path.is_empty()
-                                && crate::data::carried_field_paths(p, r)
-                                    .iter()
-                                    .any(|f| f.field == value.field))
-                    })
-                    .cloned()
-                    .collect();
-                (e.id, retained)
-            }),
+            }) => p
+                .relations
+                .get(id)
+                .map(|r| (e.id, crate::validation::carried_fields(p, r))),
             _ => None,
         })
         .collect();
-    for (id, retained) in allowed {
+    for (id, fields) in allowed {
         if let Some(SharedBody::Occurrence {
             body: OccurrenceBody::Exchange { values, .. },
             ..
         }) = p.elements.get_mut(&id).and_then(Element::shared_mut)
         {
-            *values = retained;
+            values.retain(|value| fields.contains(&value.field));
         }
     }
 }

crates/oa-core/src/routing.rs

@@ -1,7 +1,7 @@
 //! Deterministic, bounded diagram geometry. Only authored pins belong in the model;
 //! callers share this derived geometry for drawing, picking, fitting and export.
 use crate::projection::{self, ProjectedEdge, ProjectedNode, ProjectedView};
-use crate::{Diagram, Id, Position, Project, Relation, RelationBody, RelationKind, Size};
+use crate::{Diagram, Id, Position, Project, RelationKind, Size};
 use std::cmp::Ordering;
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap};
 use std::fmt;
@@ -55,122 +55,6 @@ pub struct EdgeLabelGeometry {
     pub bounds: RoutingBounds,
 }
 
-/// Derived labels and navigation markers for the two named association ends.
-/// Canvas and SVG consume these same coordinates; no extra diagram state exists.
-#[derive(Debug, Clone, PartialEq)]
-pub struct AssociationEndGeometry {
-    pub source_end: bool,
-    pub label: EdgeLabelGeometry,
-    pub tip: Position,
-    pub inward: Position,
-    pub navigable: bool,
-}
-
-pub fn association_end_geometry(
-    relation: &Relation,
-    routed: &RoutedEdge,
-) -> Vec<AssociationEndGeometry> {
-    let RelationBody::DataAssociation {
-        source_navigable,
-        target_navigable,
-        ..
-    } = &relation.body
-    else {
-        return Vec::new();
-    };
-    let mut ends: Vec<AssociationEndGeometry> = Vec::new();
-    for (source_end, navigable) in [(true, *source_navigable), (false, *target_navigable)] {
-        let Some(tip) = (if source_end {
-            routed.points.first()
-        } else {
-            routed.points.last()
-        })
-        .copied() else {
-            continue;
-        };
-        let inward = if source_end {
-            routed.points.iter().find(|p| **p != tip)
-        } else {
-            routed.points.iter().rev().find(|p| **p != tip)
-        };
-        let Some(inward) = inward.copied() else {
-            continue;
-        };
-        let full = crate::data::association_end_label(relation, source_end).unwrap_or_default();
-        let text = if let Some((role, multiplicity)) = full.rsplit_once(" [") {
-            let role = if role.chars().count() > 32 {
-                role.chars()
-                    .take(31)
-                    .chain(std::iter::once('…'))
-                    .collect::<String>()
-            } else {
-                role.to_owned()
-            };
-            format!("{role} [{multiplicity}")
-        } else {
-            full
-        };
-        let size = Size {
-            width: text.chars().count() as f32 * 7.0 + 12.0,
-            height: 22.0,
-        };
-        let dx = inward.x - tip.x;
-        let dy = inward.y - tip.y;
-        let length = dx.hypot(dy);
-        let direction = pos(dx / length, dy / length);
-        // One normal sign puts opposite endpoints of a straight edge on
-        // opposite sides because their inward tangent directions are reversed.
-        let along =
-            direction.x.abs() * size.width / 2.0 + direction.y.abs() * size.height / 2.0 + 12.0;
-        let normal =
-            direction.y.abs() * size.width / 2.0 + direction.x.abs() * size.height / 2.0 + 8.0;
-        let mut center = pos(
-            tip.x + direction.x * along - direction.y * normal,
-            tip.y + direction.y * along + direction.x * normal,
-        );
-        if let Some(other) = ends.first()
-            && (center.x - other.label.center.x).abs()
-                < (size.width + other.label.bounds.size.width) / 2.0 + 6.0
-            && (center.y - other.label.center.y).abs()
-                < (size.height + other.label.bounds.size.height) / 2.0 + 6.0
-        {
-            // Same-side anchors on a self-loop can still be close. Separate
-            // their complete bounds along this end's normal in one step.
-            let perpendicular = pos(-direction.y, direction.x);
-            let distance = (center.x - other.label.center.x) * perpendicular.x
-                + (center.y - other.label.center.y) * perpendicular.y;
-            let clearance = (perpendicular.x.abs() * (size.width + other.label.bounds.size.width)
-                + perpendicular.y.abs() * (size.height + other.label.bounds.size.height))
-                / 2.0
-                + 8.0;
-            let shift = if distance < 0.0 {
-                -clearance - distance
-            } else {
-                clearance - distance
-            };
-            center.x += perpendicular.x * shift;
-            center.y += perpendicular.y * shift;
-        }
-        ends.push(AssociationEndGeometry {
-            source_end,
-            label: EdgeLabelGeometry {
-                text,
-                fraction: if source_end { 0.0 } else { 1.0 },
-                anchor: tip,
-                center,
-                bounds: RoutingBounds {
-                    position: pos(center.x - size.width / 2.0, center.y - size.height / 2.0),
-                    size,
-                },
-            },
-            tip,
-            inward,
-            navigable,
-        });
-    }
-    ends
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum RouteWarning {
     PinInsideObstacle { pin: usize, obstacle: Id },
@@ -582,14 +466,6 @@ fn route_diagram_impl(
     // never changes paths or authored metadata. Previews retain other cached
     // labels and avoid the paths actually shown during the gesture.
     let mut previous_labels = Vec::new();
-    for routed in edges.values() {
-        if let Some(relation) = project.relations.get(&routed.id) {
-            for end in association_end_geometry(relation, routed) {
-                bounds.rect(end.label.bounds.position, end.label.bounds.size);
-                previous_labels.push(end.label.bounds);
-            }
-        }
-    }
     for edge in ordered {
         let Some(routed) = edges.get_mut(&edge.id) else {
             continue;
@@ -703,7 +579,7 @@ fn route_edge(
     let mut candidates = Vec::new();
     for a in endpoints(source, edge.source_port, view) {
         for b in endpoints(target, edge.target_port, view) {
-            // A real self-relation must leave and return at distinct anchors.
+            // A real self-transition must leave and return at distinct anchors.
             // Reusing one anchor makes the cheapest path a degenerate stub.
             if edge.source == edge.target
                 && edge.source_port.is_none()
@@ -1231,8 +1107,7 @@ fn label_text(project: &Project, edge: Id) -> String {
     let text = match relation.kind() {
         RelationKind::Interaction
         | RelationKind::FunctionalExchange
-        | RelationKind::BoundaryExchange
-        | RelationKind::DataAssociation => relation.name.as_str(),
+        | RelationKind::BoundaryExchange => relation.name.as_str(),
         RelationKind::CapabilityInclude => "«include»",
         RelationKind::CapabilityExtend => "«extend»",
         RelationKind::CapabilityGeneralization => "specializes",

crates/oa-core/src/semantic.rs

@@ -1,16 +0,0 @@
-//! Closed typed facts for deliberately reviewed OA/SA semantics.
-//!
-//! Historical facts are independently acknowledged observations, not a synthetic
-//! live model. Their UUIDs are not live references and survive ordinary deletion.
-mod catalog;
-mod historical;
-mod linked;
-mod mutate;
-mod review;
-mod types;
-pub use catalog::*;
-pub(crate) use historical::{HistoricalSourceKind, historical_source_slots};
-pub use historical::{validate_semantic_baseline, visit_semantic_references};
-pub use linked::*;
-pub use review::*;
-pub use types::*;

crates/oa-core/src/semantic/historical.rs

@@ -1,404 +0,0 @@
-use super::types::*;
-use crate::model::*;
-use std::collections::BTreeSet;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum HistoricalSourceKind {
-    Reference,
-    Enum,
-}
-
-const MAX_FACTS: usize = 16_384;
-const MAX_LEAVES: usize = 1_000_000;
-const MAX_PATH: usize = 128;
-
-struct Walk<'a> {
-    path: Vec<String>,
-    slots: Vec<(Vec<String>, HistoricalSourceKind)>,
-    errors: Vec<String>,
-    leaves: usize,
-    visitor: &'a mut dyn FnMut(&mut Id),
-}
-impl Walk<'_> {
-    fn at(&mut self, key: impl ToString, f: impl FnOnce(&mut Self)) {
-        if self.leaves >= MAX_LEAVES {
-            return;
-        }
-        self.leaves += 1;
-        self.path.push(key.to_string());
-        f(self);
-        self.path.pop();
-    }
-    fn slot(&mut self, kind: HistoricalSourceKind) {
-        self.slots.push((self.path.clone(), kind));
-    }
-    fn error(&mut self, message: &str) {
-        self.errors
-            .push(format!("{}: {message}", self.path.join(".")));
-    }
-}
-trait Historical {
-    fn walk(&mut self, w: &mut Walk<'_>);
-}
-impl Historical for Id {
-    fn walk(&mut self, w: &mut Walk<'_>) {
-        w.slot(HistoricalSourceKind::Reference);
-        (w.visitor)(self);
-    }
-}
-macro_rules! plain {
-    ($($ty:ty),*) => { $( impl Historical for $ty { fn walk(&mut self, _: &mut Walk<'_>) {} } )* };
-}
-plain!(bool, u32, i64);
-impl Historical for String {
-    fn walk(&mut self, w: &mut Walk<'_>) {
-        if !crate::validation::valid_text(self) {
-            w.error("historical text contains an invalid character");
-        }
-        if self.len() > 1_000_000 {
-            w.error("historical text work limit exceeded");
-        }
-    }
-}
-impl Historical for f64 {
-    fn walk(&mut self, w: &mut Walk<'_>) {
-        if !self.is_finite() {
-            w.error("historical real must be finite");
-        }
-    }
-}
-macro_rules! enums {
-    ($($ty:ty),*) => { $( impl Historical for $ty {
-        fn walk(&mut self, w: &mut Walk<'_>) { w.slot(HistoricalSourceKind::Enum); }
-    } )* };
-}
-enums!(
-    ExchangeItemKind,
-    ExchangeMechanism,
-    ParameterDirection,
-    FieldStorage,
-    ComponentPortKind,
-    ComponentPortOrientation,
-    PortDirection,
-    ScenarioViewpoint,
-    ControlKind,
-    FragmentOperator,
-    TimeEventKind,
-    StateKind,
-    TransmissionProtocol,
-    AcquisitionProtocol,
-    TransitionKind,
-    StateActionKind,
-    ArtifactRelation,
-    ReferenceCollection,
-    OrderedCollection,
-    IncidentEnd,
-    DataConstructor,
-    PortConstructor,
-    OccurrenceConstructor,
-    EventConstructor,
-    MessageConstructor
-);
-impl<T: Historical> Historical for Option<T> {
-    fn walk(&mut self, w: &mut Walk<'_>) {
-        if let Some(v) = self {
-            v.walk(w);
-        }
-    }
-}
-impl<T: Historical> Historical for Vec<T> {
-    fn walk(&mut self, w: &mut Walk<'_>) {
-        for (i, v) in self.iter_mut().enumerate().take(MAX_LEAVES) {
-            w.at(i, |w| v.walk(w));
-        }
-        if self.len() > MAX_LEAVES {
-            w.error("historical collection work limit exceeded");
-        }
-    }
-}
-impl<T: Historical> Historical for Observed<T> {
-    fn walk(&mut self, w: &mut Walk<'_>) {
-        match self {
-            Self::NotApplicable => w.slot(HistoricalSourceKind::Enum),
-            Self::Value(v) => w.at("Value", |w| v.walk(w)),
-        }
-    }
-}
-impl<T: Historical> Historical for Reviewed<T> {
-    fn walk(&mut self, w: &mut Walk<'_>) {
-        if matches!(
-            (&self.oa, &self.sa),
-            (Observed::NotApplicable, Observed::NotApplicable)
-        ) {
-            w.error("a reviewed facet must apply on at least one side");
-        }
-        w.at("oa", |w| self.oa.walk(w));
-        w.at("sa", |w| self.sa.walk(w));
-    }
-}
-impl<T: Historical> Historical for KeyPair<T> {
-    fn walk(&mut self, w: &mut Walk<'_>) {
-        if self.oa.is_none() && self.sa.is_none() {
-            w.error("key pair cannot be empty on both sides");
-        }
-        w.at("oa", |w| self.oa.walk(w));
-        w.at("sa", |w| self.sa.walk(w));
-    }
-}
-impl Historical for AnnotationKey {
-    fn walk(&mut self, w: &mut Walk<'_>) {
-        if self.path.len() > MAX_PATH {
-            w.error("historical annotation path limit exceeded");
-        }
-        w.at("path", |w| self.path.walk(w));
-        w.at("field", |w| self.field.walk(w));
-    }
-}
-impl Historical for MessageValue {
-    fn walk(&mut self, w: &mut Walk<'_>) {
-        if self.path.len() > MAX_PATH {
-            w.error("historical annotation path limit exceeded");
-        }
-        w.at("path", |w| self.path.walk(w));
-        w.at("field", |w| self.field.walk(w));
-        w.at("expression", |w| self.expression.walk(w));
-    }
-}
-impl Historical for LifelineBinding {
-    fn walk(&mut self, w: &mut Walk<'_>) {
-        w.at("referenced", |w| self.referenced.walk(w));
-        w.at("local", |w| self.local.walk(w));
-    }
-}
-impl Historical for DataValue {
-    fn walk(&mut self, w: &mut Walk<'_>) {
-        match self {
-            Self::Real(value) => w.at("Real", |w| value.walk(w)),
-            Self::String(value) => w.at("String", |w| value.walk(w)),
-            Self::Enumeration(value) => w.at("Enumeration", |w| value.walk(w)),
-            Self::Boolean(_) | Self::Integer(_) => {}
-        }
-    }
-}
-impl Historical for TypeRef {
-    fn walk(&mut self, w: &mut Walk<'_>) {
-        match self {
-            Self::Named(id) => w.at("Named", |w| id.walk(w)),
-            _ => w.slot(HistoricalSourceKind::Enum),
-        }
-    }
-}
-impl Historical for ArtifactReview {
-    fn walk(&mut self, w: &mut Walk<'_>) {
-        match self {
-            Self::Presence(v) => w.at("Presence", |w| v.walk(w)),
-            Self::Name(v) => w.at("Name", |w| v.walk(w)),
-            Self::Description(v) => w.at("Description", |w| v.walk(w)),
-            Self::Owner(v) => w.at("Owner", |w| v.walk(w)),
-            Self::Relation(v) => w.at("Relation", |w| v.walk(w)),
-            Self::Uri(v) => w.at("Uri", |w| v.walk(w)),
-            Self::Revision(v) => w.at("Revision", |w| v.walk(w)),
-            Self::Fragment(v) => w.at("Fragment", |w| v.walk(w)),
-        }
-    }
-}
-macro_rules! family_visitor {
-    ($( $family:ident, $selector:ident, $review:ident { $( $leaf:ident: $ty:ty ),* } )*) => {
-        impl Historical for FacetReview {
-            fn walk(&mut self, w: &mut Walk<'_>) {
-                match self {
-                    $( Self::$family(v) => w.at(stringify!($family), |w| match v {
-                        $( $review::$leaf(v) => w.at(stringify!($leaf), |w| v.walk(w)), )*
-                    }), )*
-                    Self::Member { collection, keys, review } => w.at("Member", |w| {
-                        w.at("collection", |w| collection.walk(w)); w.at("keys", |w| keys.walk(w)); w.at("review", |w| review.walk(w));
-                    }),
-                    Self::Order { collection, review } => w.at("Order", |w| {
-                        w.at("collection", |w| collection.walk(w)); w.at("review", |w| review.walk(w));
-                        for side in [&review.oa, &review.sa] { if let Observed::Value(order) = side {
-                            if order.iter().collect::<BTreeSet<_>>().len() != order.len() { w.error("duplicate historical order member"); }
-                        }}
-                    }),
-                    Self::Literal { keys, review } => w.at("Literal", |w| {
-                        w.at("keys", |w| keys.walk(w)); w.at("review", |w| review.walk(w));
-                    }),
-                    Self::Annotation { keys, review } => w.at("Annotation", |w| {
-                        w.at("keys", |w| keys.walk(w)); w.at("review", |w| review.walk(w));
-                        for (key, value) in [(&keys.oa, &review.oa), (&keys.sa, &review.sa)] {
-                            if let Observed::Value(Some(row)) = value {
-                                if key.as_ref() != Some(&AnnotationKey::from(row)) { w.error("historical annotation key and payload disagree"); }
-                            }
-                        }
-                    }),
-                    Self::Binding { keys, review } => w.at("Binding", |w| {
-                        w.at("keys", |w| keys.walk(w)); w.at("review", |w| review.walk(w));
-                        for (key, value) in [(&keys.oa, &review.oa), (&keys.sa, &review.sa)] {
-                            if let Observed::Value(Some(row)) = value {
-                                if *key != Some(row.referenced) { w.error("historical binding key and payload disagree"); }
-                            }
-                        }
-                    }),
-                    Self::Child { keys, review } => w.at("Child", |w| {
-                        w.at("keys", |w| keys.walk(w)); w.at("review", |w| review.walk(w));
-                    }),
-                    Self::Incident { keys, end, review } => w.at("Incident", |w| {
-                        w.at("keys", |w| keys.walk(w)); w.at("end", |w| end.walk(w)); w.at("review", |w| review.walk(w));
-                    }),
-                    Self::Artifact { keys, review } => w.at("Artifact", |w| {
-                        w.at("keys", |w| keys.walk(w)); w.at("review", |w| review.walk(w));
-                    }),
-                }
-            }
-        }
-    };
-}
-scalar_families!(family_visitor);
-
-fn walk_baseline<'a>(
-    baseline: &mut SemanticBaseline,
-    visitor: &'a mut dyn FnMut(&mut Id),
-) -> Walk<'a> {
-    let mut walk = Walk {
-        path: vec!["facets".into()],
-        slots: vec![],
-        errors: vec![],
-        leaves: 0,
-        visitor,
-    };
-    if baseline.facets.len() > MAX_FACTS {
-        walk.error("historical facet count limit exceeded");
-    }
-    for (i, facet) in baseline.facets.iter_mut().enumerate().take(MAX_FACTS) {
-        walk.at(i, |w| facet.walk(w));
-    }
-    if walk.leaves >= MAX_LEAVES {
-        walk.error("historical reference work limit exceeded");
-    }
-    walk
-}
-/// Historical UUIDs are visited only on explicit identity remapping, never deletion.
-pub fn visit_semantic_references(
-    baseline: &mut SemanticBaseline,
-    mut visitor: impl FnMut(&mut Id),
-) {
-    walk_baseline(baseline, &mut visitor);
-}
-pub(crate) fn historical_source_slots(
-    baseline: &SemanticBaseline,
-) -> Vec<(Vec<String>, HistoricalSourceKind)> {
-    walk_baseline(&mut baseline.clone(), &mut |_| {}).slots
-}
-/// Checks persisted facts without demanding that historical references still exist.
-pub fn validate_semantic_baseline(baseline: &SemanticBaseline) -> Result<(), Vec<String>> {
-    let mut errors = walk_baseline(&mut baseline.clone(), &mut |_| {}).errors;
-    let mut slots = BTreeSet::new();
-    for selector in baseline
-        .facets
-        .iter()
-        .take(MAX_FACTS)
-        .map(FacetReview::selector)
-    {
-        if selector_slots(&selector)
-            .into_iter()
-            .any(|slot| !slots.insert(slot))
-        {
-            errors.push(format!(
-                "duplicate or overlapping historical facet: {selector:?}"
-            ));
-        }
-    }
-    if errors.is_empty() {
-        Ok(())
-    } else {
-        Err(errors)
-    }
-}
-pub(super) fn selector_slots(selector: &FacetSelector) -> Vec<FacetSelector> {
-    fn split<T: Clone>(keys: &KeyPair<T>) -> Vec<KeyPair<T>> {
-        let mut result = vec![];
-        if let Some(oa) = &keys.oa {
-            result.push(KeyPair {
-                oa: Some(oa.clone()),
-                sa: None,
-            });
-        }
-        if let Some(sa) = &keys.sa {
-            result.push(KeyPair {
-                oa: None,
-                sa: Some(sa.clone()),
-            });
-        }
-        result
-    }
-    match selector {
-        FacetSelector::Member { collection, keys } => split(keys)
-            .into_iter()
-            .map(|keys| FacetSelector::Member {
-                collection: *collection,
-                keys,
-            })
-            .collect(),
-        FacetSelector::Literal(keys) => split(keys)
-            .into_iter()
-            .map(FacetSelector::Literal)
-            .collect(),
-        FacetSelector::Annotation(keys) => split(keys)
-            .into_iter()
-            .map(FacetSelector::Annotation)
-            .collect(),
-        FacetSelector::Binding(keys) => split(keys)
-            .into_iter()
-            .map(FacetSelector::Binding)
-            .collect(),
-        FacetSelector::Child(keys) => split(keys).into_iter().map(FacetSelector::Child).collect(),
-        FacetSelector::Incident { keys, end } => split(keys)
-            .into_iter()
-            .map(|keys| FacetSelector::Incident { keys, end: *end })
-            .collect(),
-        FacetSelector::Artifact { keys, facet } => split(keys)
-            .into_iter()
-            .map(|keys| FacetSelector::Artifact {
-                keys,
-                facet: *facet,
-            })
-            .collect(),
-        value => vec![value.clone()],
-    }
-}
-fn pair_overlap<T: Eq>(a: &KeyPair<T>, b: &KeyPair<T>) -> bool {
-    a.oa.as_ref()
-        .zip(b.oa.as_ref())
-        .is_some_and(|(a, b)| a == b)
-        || a.sa
-            .as_ref()
-            .zip(b.sa.as_ref())
-            .is_some_and(|(a, b)| a == b)
-}
-/// Slot identity is each actual side's key, not equality of the complete pair.
-pub(crate) fn keyed_slots_overlap(a: &FacetSelector, b: &FacetSelector) -> bool {
-    match (a, b) {
-        (
-            FacetSelector::Member {
-                collection: a,
-                keys: ak,
-            },
-            FacetSelector::Member {
-                collection: b,
-                keys: bk,
-            },
-        ) => a == b && pair_overlap(ak, bk),
-        (FacetSelector::Literal(a), FacetSelector::Literal(b)) => pair_overlap(a, b),
-        (FacetSelector::Annotation(a), FacetSelector::Annotation(b)) => pair_overlap(a, b),
-        (FacetSelector::Binding(a), FacetSelector::Binding(b)) => pair_overlap(a, b),
-        (FacetSelector::Child(a), FacetSelector::Child(b)) => pair_overlap(a, b),
-        (
-            FacetSelector::Incident { keys: ak, end: a },
-            FacetSelector::Incident { keys: bk, end: b },
-        ) => a == b && pair_overlap(ak, bk),
-        (
-            FacetSelector::Artifact { keys: ak, facet: a },
-            FacetSelector::Artifact { keys: bk, facet: b },
-        ) => a == b && pair_overlap(ak, bk),
-        _ => a == b,
-    }
-}

crates/oa-core/src/semantic/linked.rs

@@ -1,174 +0,0 @@
-use super::*;
-use crate::model::*;
-use crate::transitions::Drift;
-use serde::{Deserialize, Serialize};
-use std::collections::{BTreeMap, BTreeSet, VecDeque};
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct LinkedSemanticImpact {
-    pub objects: KeyPair<Id>,
-    pub traces: Vec<Id>,
-    pub drift: Drift,
-    pub unreviewed: bool,
-}
-const MAX_LINKED_OBJECTS: usize = 4_096;
-const MAX_LINKED_EDGES: usize = 32_768;
-
-/// Derived dependency diagnostics, never another historical baseline. Follow
-/// direct references/children, then only reusable dictionary/event definitions.
-/// Association endpoints and ordinary architecture neighborhoods do not expand.
-pub fn linked_semantic_impacts(
-    project: &Project,
-    trace: &Trace,
-    references: &BTreeMap<Id, Id>,
-) -> Result<Vec<LinkedSemanticImpact>, String> {
-    let mut children: BTreeMap<Id, Vec<Id>> = BTreeMap::new();
-    for element in project.elements.values() {
-        if let Some(parent) = element.parent {
-            children.entry(parent).or_default().push(element.id);
-        }
-    }
-    let mut contracts: BTreeMap<Id, Vec<Id>> = BTreeMap::new();
-    for relation in project.relations.values() {
-        if let RelationBody::InterfaceItemAllocation { source, .. } = relation.body {
-            contracts.entry(source).or_default().push(relation.id);
-        }
-    }
-    let direct = |id| -> Vec<Id> {
-        let mut out = vec![];
-        if let Some(element) = project.elements.get(&id) {
-            out.extend(
-                crate::references::element_references(element)
-                    .into_iter()
-                    .filter(|r| Some(*r) != element.parent),
-            );
-        }
-        if let Some(relation) = project.relations.get(&id) {
-            out.extend(crate::references::relation_references(relation));
-        }
-        out.extend(children.get(&id).into_iter().flatten().copied());
-        out.extend(contracts.get(&id).into_iter().flatten().copied());
-        out
-    };
-    let expandable = |id| {
-        project.elements.get(&id).is_some_and(|e| {
-            matches!(
-                e.kind(),
-                Kind::DataType
-                    | Kind::DataField
-                    | Kind::ExchangeItem
-                    | Kind::Interface
-                    | Kind::Event
-            )
-        }) || project
-            .relations
-            .get(&id)
-            .is_some_and(|r| matches!(r.body, RelationBody::InterfaceItemAllocation { .. }))
-    };
-    let mut edges = 0usize;
-    let mut traverse = |root| -> Result<BTreeSet<Id>, String> {
-        let mut seen = BTreeSet::from([root]);
-        let first = direct(root);
-        edges += first.len();
-        if edges > MAX_LINKED_EDGES {
-            return Err(
-                "Linked semantic dependency work limit exceeded; narrow the review scope".into(),
-            );
-        }
-        let mut queue: VecDeque<_> = first.into();
-        while let Some(id) = queue.pop_front() {
-            if !seen.insert(id) {
-                continue;
-            }
-            if seen.len() > MAX_LINKED_OBJECTS || edges > MAX_LINKED_EDGES {
-                return Err(
-                    "Linked semantic dependency work limit exceeded; narrow the review scope"
-                        .into(),
-                );
-            }
-            if expandable(id) {
-                let next = direct(id);
-                edges += next.len();
-                if edges > MAX_LINKED_EDGES {
-                    return Err(
-                        "Linked semantic dependency work limit exceeded; narrow the review scope"
-                            .into(),
-                    );
-                }
-                queue.extend(next);
-            }
-        }
-        seen.remove(&root);
-        Ok(seen)
-    };
-    let oa = traverse(trace.oa)?;
-    let sa = traverse(trace.sa)?;
-    let mut traced: BTreeMap<(Id, Id), Vec<&Trace>> = BTreeMap::new();
-    for t in project.traces.values() {
-        traced.entry((t.oa, t.sa)).or_default().push(t);
-    }
-    let mut pairs = vec![];
-    let mut used = BTreeSet::new();
-    for id in oa {
-        let target = references.get(&id).copied();
-        if let Some(id) = target {
-            used.insert(id);
-        }
-        pairs.push(KeyPair {
-            oa: Some(id),
-            sa: target,
-        });
-    }
-    for id in sa.difference(&used) {
-        pairs.push(KeyPair {
-            oa: None,
-            sa: Some(*id),
-        });
-    }
-    let mut result = vec![];
-    for objects in pairs {
-        if objects.oa == Some(trace.oa) && objects.sa == Some(trace.sa) {
-            continue;
-        }
-        let links = objects
-            .oa
-            .zip(objects.sa)
-            .and_then(|pair| traced.get(&pair));
-        let mut flags = (false, false, links.is_none());
-        let mut ids = vec![];
-        for linked in links.into_iter().flatten() {
-            ids.push(linked.id);
-            let facts = super::catalog::own_semantic_facets(project, linked, references)?;
-            if facts.is_empty() {
-                flags.2 = true;
-            }
-            for fact in facts {
-                match fact.drift {
-                    Drift::OaChanged => flags.0 = true,
-                    Drift::SaChanged => flags.1 = true,
-                    Drift::BothChanged => {
-                        flags.0 = true;
-                        flags.1 = true;
-                    }
-                    Drift::Unreviewed => flags.2 = true,
-                    _ => {}
-                }
-            }
-        }
-        let drift = match flags {
-            (true, true, _) => Drift::BothChanged,
-            (true, false, _) => Drift::OaChanged,
-            (false, true, _) => Drift::SaChanged,
-            (false, false, true) => Drift::Unreviewed,
-            _ => Drift::Unchanged,
-        };
-        result.push(LinkedSemanticImpact {
-            objects,
-            traces: ids,
-            drift,
-            unreviewed: flags.2,
-        });
-    }
-    Ok(result)
-}

crates/oa-core/src/semantic/mutate.rs

@@ -1,592 +0,0 @@
-use super::catalog::{collection, order_collection, sides, write_scalar};
-use super::*;
-use crate::model::*;
-use crate::transitions::TransitionDirection;
-use std::collections::{BTreeMap, BTreeSet};
-
-pub(crate) fn set_collection(
-    p: &mut Project,
-    id: Id,
-    which: ReferenceCollection,
-    list: Vec<Id>,
-) -> Result<(), String> {
-    if list.iter().collect::<BTreeSet<_>>().len() != list.len() {
-        return Err("Collection contains duplicate members".into());
-    }
-    use ReferenceCollection as C;
-    if which == C::Steps {
-        let e = p.elements.get_mut(&id).ok_or("Missing sequence")?;
-        if let Some(steps) = e.steps_mut() {
-            *steps = list;
-            return Ok(());
-        }
-        if let Some(SharedBody::Occurrence {
-            body: OccurrenceBody::Branch { occurrences, .. },
-            ..
-        }) = e.shared_mut()
-        {
-            *occurrences = list;
-            return Ok(());
-        }
-        return Err("Target has no ordered steps".into());
-    }
-    let slot = match which {
-        C::Steps => unreachable!(),
-        C::FragmentBranches => match p.elements.get_mut(&id).and_then(Element::shared_mut) {
-            Some(SharedBody::Occurrence {
-                body: OccurrenceBody::Fragment { branches, .. },
-                ..
-            }) => Some(branches),
-            _ => None,
-        },
-        C::FunctionInputItems => match p.elements.get_mut(&id).and_then(Element::shared_mut) {
-            Some(SharedBody::Port {
-                contract: PortContract::FunctionInput { incoming_items },
-                ..
-            }) => Some(incoming_items),
-            _ => None,
-        },
-        C::FunctionOutputItems => match p.elements.get_mut(&id).and_then(Element::shared_mut) {
-            Some(SharedBody::Port {
-                contract: PortContract::FunctionOutput { outgoing_items },
-                ..
-            }) => Some(outgoing_items),
-            _ => None,
-        },
-        C::SignalItems => match p.elements.get_mut(&id).and_then(Element::shared_mut) {
-            Some(SharedBody::Event {
-                body: EventBody::Signal { items },
-            }) => Some(items),
-            _ => None,
-        },
-        C::ExchangeItems => match p.relations.get_mut(&id).map(|r| &mut r.body) {
-            Some(
-                RelationBody::Interaction { items, .. }
-                | RelationBody::FunctionalExchange { items, .. }
-                | RelationBody::BoundaryExchange { items, .. },
-            ) => Some(items),
-            _ => None,
-        },
-        C::TransitionTriggers => match p.relations.get_mut(&id).map(|r| &mut r.body) {
-            Some(RelationBody::StateTransition { triggers, .. }) => Some(triggers),
-            _ => None,
-        },
-        C::TransitionEffects => match p.relations.get_mut(&id).map(|r| &mut r.body) {
-            Some(RelationBody::StateTransition { effects, .. }) => Some(effects),
-            _ => None,
-        },
-        C::Constrained => match p.elements.get_mut(&id).and_then(Element::shared_mut) {
-            Some(SharedBody::Constraint { constrained, .. }) => Some(constrained),
-            _ => None,
-        },
-    }
-    .ok_or("Collection is inapplicable on target")?;
-    *slot = list;
-    Ok(())
-}
-pub(crate) fn chosen<T>(pair: &KeyPair<T>, layer: Layer) -> Option<&T> {
-    match layer {
-        Layer::Oa => pair.oa.as_ref(),
-        Layer::Sa => pair.sa.as_ref(),
-    }
-}
-pub(crate) fn value<T>(review: &Reviewed<T>, layer: Layer) -> Result<&T, String> {
-    match match layer {
-        Layer::Oa => &review.oa,
-        Layer::Sa => &review.sa,
-    } {
-        Observed::Value(v) => Ok(v),
-        Observed::NotApplicable => {
-            Err("Facet does not exist in the selected constructor branch".into())
-        }
-    }
-}
-pub(crate) fn directional_map(
-    map: &BTreeMap<Id, Id>,
-    direction: TransitionDirection,
-) -> Result<BTreeMap<Id, Id>, String> {
-    if direction == TransitionDirection::OaToSa {
-        return Ok(map.clone());
-    }
-    let mut inverse = BTreeMap::new();
-    for (oa, sa) in map {
-        if inverse.insert(*sa, *oa).is_some_and(|old| old != *oa) {
-            return Err(format!(
-                "Reverse reference {sa} has multiple OA correspondences; supply an unambiguous mapping"
-            ));
-        }
-    }
-    Ok(inverse)
-}
-pub(crate) fn remap_record(
-    record: &mut SemanticRecord,
-    map: &BTreeMap<Id, Id>,
-) -> Result<(), String> {
-    let mut missing = BTreeSet::new();
-    let mut remap = |id: &mut Id| {
-        if let Some(new) = map.get(id) {
-            *id = *new;
-        } else {
-            missing.insert(*id);
-        }
-    };
-    match record {
-        SemanticRecord::Element(e) => crate::references::visit_element_refs(e, &mut remap),
-        SemanticRecord::Relation(r) => crate::references::visit_relation_refs(r, &mut remap),
-        SemanticRecord::Artifact(a) => remap(&mut a.owner),
-    }
-    if missing.is_empty() {
-        Ok(())
-    } else {
-        Err(format!(
-            "Missing explicit reference correspondence: {missing:?}"
-        ))
-    }
-}
-pub(crate) fn remap_fact(
-    fact: &FacetReview,
-    map: &BTreeMap<Id, Id>,
-    source: Layer,
-) -> Result<FacetReview, String> {
-    // Remap only the selected observation. Keys remain in canonical OA/SA space.
-    let mut json = serde_json::to_value(fact).map_err(|e| e.to_string())?;
-    let base = SemanticBaseline {
-        facets: vec![fact.clone()],
-    };
-    let side = match source {
-        Layer::Oa => "oa",
-        Layer::Sa => "sa",
-    };
-    let mut missing = BTreeSet::new();
-    for (path, kind) in historical_source_slots(&base) {
-        if kind != HistoricalSourceKind::Reference {
-            continue;
-        }
-        let rest = &path[2..];
-        if !rest.windows(2).any(|w| w[0] == side && w[1] == "Value") {
-            continue;
-        }
-        let mut leaf = &mut json;
-        for part in rest {
-            leaf = if leaf.is_array() {
-                leaf.get_mut(
-                    part.parse::<usize>()
-                        .map_err(|_| "Invalid historical array index")?,
-                )
-            } else {
-                leaf.get_mut(part)
-            }
-            .ok_or("Invalid historical source slot")?;
-        }
-        let id: Id = serde_json::from_value(leaf.clone()).map_err(|e| e.to_string())?;
-        if let Some(new) = map.get(&id) {
-            *leaf = serde_json::to_value(new).unwrap();
-        } else {
-            missing.insert(id);
-        }
-    }
-    if !missing.is_empty() {
-        return Err(format!(
-            "Missing explicit reference correspondence: {missing:?}"
-        ));
-    }
-    serde_json::from_value(json).map_err(|e| e.to_string())
-}
-pub(crate) fn check_keys(selector: &FacetSelector, map: &BTreeMap<Id, Id>) -> Result<(), String> {
-    fn pair(keys: &KeyPair<Id>, map: &BTreeMap<Id, Id>) -> Result<(), String> {
-        if let (Some(oa), Some(sa)) = (keys.oa, keys.sa)
-            && map.get(&oa) != Some(&sa)
-        {
-            return Err("Key pair disagrees with frozen reference correspondence".into());
-        }
-        if keys.oa.is_none() && keys.sa.is_none() {
-            return Err("Empty key pair".into());
-        }
-        Ok(())
-    }
-    match selector {
-        FacetSelector::Member { keys, .. }
-        | FacetSelector::Binding(keys)
-        | FacetSelector::Child(keys)
-        | FacetSelector::Incident { keys, .. }
-        | FacetSelector::Artifact { keys, .. } => pair(keys, map),
-        FacetSelector::Annotation(keys) => {
-            if let (Some(oa), Some(sa)) = (&keys.oa, &keys.sa) {
-                if oa.path.len() != sa.path.len() {
-                    return Err("Annotation path pairing disagrees".into());
-                }
-                for (oa, sa) in oa
-                    .path
-                    .iter()
-                    .chain([&oa.field])
-                    .zip(sa.path.iter().chain([&sa.field]))
-                {
-                    pair(
-                        &KeyPair {
-                            oa: Some(*oa),
-                            sa: Some(*sa),
-                        },
-                        map,
-                    )?;
-                }
-            }
-            if keys.oa.is_none() && keys.sa.is_none() {
-                return Err("Empty annotation pair".into());
-            }
-            Ok(())
-        }
-        FacetSelector::Literal(keys) => {
-            if keys
-                .oa
-                .as_ref()
-                .zip(keys.sa.as_ref())
-                .is_some_and(|(oa, sa)| oa != sa)
-            {
-                return Err(
-                    "Enum literal identity is exact text; renaming is removal/addition".into(),
-                );
-            }
-            Ok(())
-        }
-        _ => Ok(()),
-    }
-}
-
-/// Apply just one selected fact to an in-memory expected project. The caller
-/// subsequently prepares ordinary Commands and checks every induced difference.
-pub(crate) fn write_fact(
-    p: &mut Project,
-    target: Id,
-    fact: &FacetReview,
-    from: Layer,
-    target_layer: Layer,
-    preserve_target_only: bool,
-) -> Result<(), String> {
-    match fact {
-        FacetReview::Member {
-            collection: which,
-            keys,
-            review,
-        } => {
-            if preserve_target_only && chosen(keys, from).is_none() {
-                return Ok(());
-            }
-            let present = *value(review, from)?;
-            let key = chosen(keys, target_layer)
-                .copied()
-                .ok_or("Map the target collection member explicitly")?;
-            let mut list = collection(p, target, *which).ok_or("Inapplicable target collection")?;
-            if present {
-                if !list.contains(&key) {
-                    list.push(key);
-                }
-            } else {
-                list.retain(|id| *id != key);
-            }
-            set_collection(p, target, *which, list)
-        }
-        FacetReview::Order {
-            collection: which,
-            review,
-        } => {
-            let supplied = value(review, from)?.clone();
-            let current = collection(p, target, order_collection(*which))
-                .ok_or("Inapplicable target order")?;
-            let supplied_set: BTreeSet<_> = supplied.iter().copied().collect();
-            let current_set: BTreeSet<_> = current.iter().copied().collect();
-            if supplied_set != current_set {
-                if preserve_target_only
-                    && supplied_set.is_subset(&current_set)
-                    && current
-                        .iter()
-                        .filter(|id| supplied_set.contains(id))
-                        .copied()
-                        .collect::<Vec<_>>()
-                        == supplied
-                {
-                    return Ok(());
-                }
-                return Err("Order must contain every surviving target member exactly once; target-only insertion requires an explicit final order".into());
-            }
-            set_collection(p, target, order_collection(*which), supplied)
-        }
-        FacetReview::Literal { keys, review } => {
-            if preserve_target_only && chosen(keys, from).is_none() {
-                return Ok(());
-            }
-            let present = *value(review, from)?;
-            let key = chosen(keys, target_layer).ok_or("Missing literal key on target")?;
-            let Some(SharedBody::DataType {
-                definition: DataTypeDefinition::Enumeration { literals },
-                ..
-            }) = p.elements.get_mut(&target).and_then(Element::shared_mut)
-            else {
-                return Err("Target is not an enumeration".into());
-            };
-            if present {
-                if !literals.contains(key) {
-                    literals.push(key.clone());
-                }
-            } else {
-                literals.retain(|v| v != key);
-            }
-            Ok(())
-        }
-        FacetReview::Annotation { keys, review } => {
-            if preserve_target_only && chosen(keys, from).is_none() {
-                return Ok(());
-            }
-            let key = chosen(keys, target_layer).ok_or("Missing target annotation key")?;
-            let row = value(review, from)?.clone();
-            if row.as_ref().is_some_and(|v| AnnotationKey::from(v) != *key) {
-                return Err(
-                    "Annotation candidate changes its row key; review removal/addition".into(),
-                );
-            }
-            let Some(SharedBody::Occurrence {
-                body: OccurrenceBody::Exchange { values, .. },
-                ..
-            }) = p.elements.get_mut(&target).and_then(Element::shared_mut)
-            else {
-                return Err("Target has no message annotations".into());
-            };
-            values.retain(|v| AnnotationKey::from(v) != *key);
-            if let Some(row) = row {
-                values.push(row);
-            }
-            Ok(())
-        }
-        FacetReview::Binding { keys, review } => {
-            if preserve_target_only && chosen(keys, from).is_none() {
-                return Ok(());
-            }
-            let key = *chosen(keys, target_layer).ok_or("Missing target binding key")?;
-            let row = value(review, from)?.clone();
-            if row.as_ref().is_some_and(|v| v.referenced != key) {
-                return Err(
-                    "Binding candidate changes its row key; review removal/addition".into(),
-                );
-            }
-            let Some(SharedBody::Occurrence {
-                body: OccurrenceBody::ScenarioUse { bindings, .. },
-                ..
-            }) = p.elements.get_mut(&target).and_then(Element::shared_mut)
-            else {
-                return Err("Target has no scenario bindings".into());
-            };
-            bindings.retain(|v| v.referenced != key);
-            if let Some(row) = row {
-                bindings.push(row);
-            }
-            Ok(())
-        }
-        FacetReview::Child { keys, review } => {
-            if preserve_target_only && chosen(keys, from).is_none() {
-                return Ok(());
-            }
-            let key = chosen(keys, target_layer).ok_or("Map target child explicitly")?;
-            let e = p
-                .elements
-                .get_mut(key)
-                .ok_or("Target child does not exist; create it through transition mapping")?;
-            if *value(review, from)? {
-                e.parent = Some(target);
-            } else if e.parent == Some(target) {
-                e.parent = None;
-            }
-            Ok(())
-        }
-        FacetReview::Incident { keys, end, review } => {
-            if preserve_target_only && chosen(keys, from).is_none() {
-                return Ok(());
-            }
-            let key = chosen(keys, target_layer).ok_or("Map incident relation explicitly")?;
-            if !*value(review, from)? {
-                return Err("Unlinking an incident relation requires an explicit final endpoint through the relation trace".into());
-            }
-            let relation = p
-                .relations
-                .get_mut(key)
-                .ok_or("Mapped incident relation is absent")?;
-            let (a, b) = relation.body.endpoints();
-            match end {
-                IncidentEnd::Source => relation.body.set_endpoints(target, b),
-                IncidentEnd::Target => relation.body.set_endpoints(a, target),
-            }
-            Ok(())
-        }
-        FacetReview::Artifact { keys, review } => {
-            if preserve_target_only && chosen(keys, from).is_none() {
-                return Ok(());
-            }
-            let key = chosen(keys, target_layer).ok_or("Map artifact explicitly")?;
-            if let ArtifactReview::Presence(review) = review {
-                if !*value(review, from)? {
-                    p.artifact_links.remove(key);
-                    return Ok(());
-                }
-                if p.artifact_links.get(key).is_some_and(|a| a.owner == target) {
-                    return Ok(());
-                }
-                return Err("Artifact creation requires a complete typed candidate".into());
-            }
-            let a = p
-                .artifact_links
-                .get_mut(key)
-                .ok_or("Artifact candidate is absent")?;
-            if a.owner != target {
-                return Err(
-                    "Artifact metadata can only be reviewed on its currently attached owner trace"
-                        .into(),
-                );
-            }
-            match review {
-                ArtifactReview::Presence(_) => unreachable!(),
-                ArtifactReview::Name(r) => a.name = value(r, from)?.clone(),
-                ArtifactReview::Description(r) => a.description = value(r, from)?.clone(),
-                ArtifactReview::Owner(r) => a.owner = *value(r, from)?,
-                ArtifactReview::Relation(r) => a.relation = *value(r, from)?,
-                ArtifactReview::Uri(r) => a.uri = value(r, from)?.clone(),
-                ArtifactReview::Revision(r) => a.revision = value(r, from)?.clone(),
-                ArtifactReview::Fragment(r) => a.fragment = value(r, from)?.clone(),
-            }
-            Ok(())
-        }
-        _ => {
-            let (oa, sa) = sides(fact);
-            let side = match from {
-                Layer::Oa => oa,
-                Layer::Sa => sa,
-            };
-            let value = side
-                .get("Value")
-                .ok_or("Selected branch is not applicable")?
-                .clone();
-            write_scalar(p, target, &fact.selector(), value)
-        }
-    }
-}
-
-pub(crate) fn constructor_contains(group: &FacetSelector, facet: &FacetSelector) -> bool {
-    use FacetSelector as F;
-    match group {
-        F::Data(DataFacet::Constructor) => {
-            matches!(facet,F::Data(f) if *f != DataFacet::Unit) || matches!(facet, F::Literal(_))
-        }
-        F::Port(PortFacet::Constructor) => matches!(
-            facet,
-            F::Port(_)
-                | F::Member {
-                    collection: ReferenceCollection::FunctionInputItems
-                        | ReferenceCollection::FunctionOutputItems,
-                    ..
-                }
-        ),
-        F::Occurrence(OccurrenceFacet::Constructor) => {
-            matches!(facet,F::Occurrence(f) if !matches!(f,OccurrenceFacet::Precondition | OccurrenceFacet::Postcondition))
-                || matches!(
-                    facet,
-                    F::Annotation(_)
-                        | F::Binding(_)
-                        | F::Member {
-                            collection: ReferenceCollection::Steps
-                                | ReferenceCollection::FragmentBranches,
-                            ..
-                        }
-                        | F::Order(_)
-                )
-        }
-        F::Occurrence(OccurrenceFacet::MessageKind) => matches!(
-            facet,
-            F::Occurrence(OccurrenceFacet::MessageKind | OccurrenceFacet::TimerExpression)
-        ),
-        F::Event(EventFacet::Constructor) => matches!(
-            facet,
-            F::Event(_)
-                | F::Member {
-                    collection: ReferenceCollection::SignalItems,
-                    ..
-                }
-        ),
-        F::State(StateFacet::Kind) => facet == group,
-        _ => false,
-    }
-}
-pub(crate) fn copy_constructor(
-    p: &mut Project,
-    target: Id,
-    source: &SemanticRecord,
-    group: &FacetSelector,
-) -> Result<(), String> {
-    let SemanticRecord::Element(source) = source else {
-        return Err("Constructor source must be an element".into());
-    };
-    let target = p
-        .elements
-        .get_mut(&target)
-        .ok_or("Missing target element")?;
-    let a = source.shared().ok_or("Source has no shared constructor")?;
-    let b = target
-        .shared_mut()
-        .ok_or("Target has no shared constructor")?;
-    match (group, a, b) {
-        (
-            FacetSelector::Data(DataFacet::Constructor),
-            SharedBody::DataType {
-                definition,
-                default,
-                ..
-            },
-            SharedBody::DataType {
-                definition: d,
-                default: v,
-                ..
-            },
-        ) => {
-            *d = definition.clone();
-            *v = default.clone();
-        }
-        (
-            FacetSelector::Port(PortFacet::Constructor),
-            SharedBody::Port { contract, legacy },
-            SharedBody::Port {
-                contract: c,
-                legacy: l,
-            },
-        ) => {
-            *c = contract.clone();
-            *l = legacy.clone();
-        }
-        (
-            FacetSelector::Occurrence(OccurrenceFacet::Constructor),
-            SharedBody::Occurrence { body, .. },
-            SharedBody::Occurrence { body: b, .. },
-        ) => *b = body.clone(),
-        (
-            FacetSelector::Occurrence(OccurrenceFacet::MessageKind),
-            SharedBody::Occurrence {
-                body: OccurrenceBody::Exchange { message_kind, .. },
-                ..
-            },
-            SharedBody::Occurrence {
-                body:
-                    OccurrenceBody::Exchange {
-                        message_kind: k, ..
-                    },
-                ..
-            },
-        ) => *k = message_kind.clone(),
-        (
-            FacetSelector::Event(EventFacet::Constructor),
-            SharedBody::Event { body },
-            SharedBody::Event { body: b },
-        ) => *b = body.clone(),
-        (
-            FacetSelector::State(StateFacet::Kind),
-            SharedBody::State { kind, .. },
-            SharedBody::State { kind: k, .. },
-        ) => *k = *kind,
-        _ => return Err("Constructor family mismatch".into()),
-    }
-    Ok(())
-}

crates/oa-core/src/semantic/types.rs

@@ -1,255 +0,0 @@
-use crate::model::*;
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub enum Observed<T> {
-    NotApplicable,
-    Value(T),
-}
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct Reviewed<T> {
-    pub oa: Observed<T>,
-    pub sa: Observed<T>,
-}
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct KeyPair<K> {
-    pub oa: Option<K>,
-    pub sa: Option<K>,
-}
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct AnnotationKey {
-    pub path: Vec<Id>,
-    pub field: Id,
-}
-impl From<&MessageValue> for AnnotationKey {
-    fn from(value: &MessageValue) -> Self {
-        Self {
-            path: value.path.clone(),
-            field: value.field,
-        }
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub enum DataConstructor {
-    Boolean,
-    Integer,
-    Real,
-    String,
-    Enumeration,
-    Record,
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub enum PortConstructor {
-    FunctionInput,
-    FunctionOutput,
-    Component,
-    Legacy,
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub enum OccurrenceConstructor {
-    Exchange,
-    Action,
-    Control,
-    SequenceReference,
-    ScenarioUse,
-    State,
-    Fragment,
-    Branch,
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub enum EventConstructor {
-    Signal,
-    Time,
-    Change,
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub enum MessageConstructor {
-    Asynchronous,
-    Call,
-    Reply,
-    Create,
-    Delete,
-    Timer,
-}
-
-// This finite catalog is also consumed by the typed historical leaf visitor.
-// Each selector fixes its payload type; there is no arbitrary value/path schema.
-macro_rules! scalar_families {
-    ($m:ident) => { $m! {
-        Header, HeaderFacet, HeaderReview {
-            Name: String, Description: String, Parent: Option<Id>
-        }
-        ExchangeItem, ExchangeItemFacet, ExchangeItemReview {
-            Nature: ExchangeItemKind, Mechanism: ExchangeMechanism, Supertype: Option<Id>
-        }
-        Interface, InterfaceFacet, InterfaceReview { Supertype: Option<Id> }
-        Data, DataFacet, DataReview {
-            Constructor: DataConstructor,
-            IntegerMinimum: Option<i64>, IntegerMaximum: Option<i64>,
-            RealMinimum: Option<f64>, RealMaximum: Option<f64>,
-            StringMinimumLength: u32, StringMaximumLength: Option<u32>,
-            RecordSupertype: Option<Id>, Default: Option<DataValue>, Unit: String
-        }
-        Field, FieldFacet, FieldReview {
-            Type: TypeRef, Minimum: u32, Maximum: Option<u32>, Unit: String,
-            Direction: ParameterDirection, Storage: FieldStorage, Default: Option<Vec<DataValue>>
-        }
-        Port, PortFacet, PortReview {
-            Constructor: PortConstructor, ComponentKind: ComponentPortKind,
-            Orientation: ComponentPortOrientation, LegacyDirection: PortDirection,
-            LegacyInterface: Option<Id>
-        }
-        Scenario, ScenarioFacet, ScenarioReview {
-            Viewpoint: ScenarioViewpoint, Context: Option<Id>, Precondition: String, Postcondition: String
-        }
-        Lifeline, LifelineFacet, LifelineReview { Represented: Option<Id> }
-        Occurrence, OccurrenceFacet, OccurrenceReview {
-            Constructor: OccurrenceConstructor, Precondition: String, Postcondition: String,
-            Exchange: Option<Id>, Sender: Option<Id>, Receiver: Option<Id>,
-            MessageKind: MessageConstructor, TimerExpression: String, ReplyTo: Option<Id>,
-            Action: Option<Id>, ActionLifeline: Option<Id>, ControlKind: ControlKind,
-            Sequence: Option<Id>, Scenario: Option<Id>, State: Option<Id>,
-            StateLifeline: Option<Id>, FragmentOperator: FragmentOperator, BranchGuard: String
-        }
-        Event, EventFacet, EventReview {
-            Constructor: EventConstructor, TimeKind: TimeEventKind, TimeExpression: String, ChangeExpression: String
-        }
-        State, StateFacet, StateReview { Kind: StateKind, Entry: String, Exit: String, DoActivity: String }
-        Constraint, ConstraintFacet, ConstraintReview { Expression: String }
-        Relation, RelationFacet, RelationReview {
-            Source: Id, Target: Id, AllocationOrder: u32, Transmission: TransmissionProtocol,
-            Acquisition: AcquisitionProtocol, SourceRole: String, TargetRole: String,
-            SourceMinimum: u32, SourceMaximum: Option<u32>, TargetMinimum: u32,
-            TargetMaximum: Option<u32>, SourceNavigable: bool, TargetNavigable: bool,
-            SourcePort: Id, TargetPort: Id, Oriented: bool, ExtendCondition: String,
-            SequenceGuard: String, TransitionKind: TransitionKind, Trigger: String,
-            Guard: String, Effect: String, StateActionPhase: StateActionKind
-        }
-    }};
-}
-pub(super) use scalar_families;
-
-macro_rules! define_families {
-    ($( $family:ident, $selector:ident, $review:ident { $( $leaf:ident: $ty:ty ),* } )*) => {
-        $(
-            #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-            pub enum $selector { $( $leaf ),* }
-            #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-            #[serde(deny_unknown_fields)]
-            pub enum $review { $( $leaf(Reviewed<$ty>) ),* }
-        )*
-        #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-        #[serde(deny_unknown_fields)]
-        pub enum FacetSelector {
-            $( $family($selector), )*
-            Member { collection: ReferenceCollection, keys: KeyPair<Id> },
-            Order(OrderedCollection),
-            Literal(KeyPair<String>),
-            Annotation(KeyPair<AnnotationKey>),
-            Binding(KeyPair<Id>),
-            Child(KeyPair<Id>),
-            Incident { keys: KeyPair<Id>, end: IncidentEnd },
-            Artifact { keys: KeyPair<Id>, facet: ArtifactFacet },
-        }
-        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-        #[serde(deny_unknown_fields)]
-        pub enum FacetReview {
-            $( $family($review), )*
-            Member { collection: ReferenceCollection, keys: KeyPair<Id>, review: Reviewed<bool> },
-            Order { collection: OrderedCollection, review: Reviewed<Vec<Id>> },
-            Literal { keys: KeyPair<String>, review: Reviewed<bool> },
-            Annotation { keys: KeyPair<AnnotationKey>, review: Reviewed<Option<MessageValue>> },
-            Binding { keys: KeyPair<Id>, review: Reviewed<Option<LifelineBinding>> },
-            Child { keys: KeyPair<Id>, review: Reviewed<bool> },
-            Incident { keys: KeyPair<Id>, end: IncidentEnd, review: Reviewed<bool> },
-            Artifact { keys: KeyPair<Id>, review: ArtifactReview },
-        }
-        impl FacetReview {
-            pub fn selector(&self) -> FacetSelector {
-                match self {
-                    $( Self::$family(value) => FacetSelector::$family(match value {
-                        $( $review::$leaf(_) => $selector::$leaf, )*
-                    }), )*
-                    Self::Member { collection, keys, .. } => FacetSelector::Member { collection: *collection, keys: keys.clone() },
-                    Self::Order { collection, .. } => FacetSelector::Order(*collection),
-                    Self::Literal { keys, .. } => FacetSelector::Literal(keys.clone()),
-                    Self::Annotation { keys, .. } => FacetSelector::Annotation(keys.clone()),
-                    Self::Binding { keys, .. } => FacetSelector::Binding(keys.clone()),
-                    Self::Child { keys, .. } => FacetSelector::Child(keys.clone()),
-                    Self::Incident { keys, end, .. } => FacetSelector::Incident { keys: keys.clone(), end: *end },
-                    Self::Artifact { keys, review } => FacetSelector::Artifact { keys: keys.clone(), facet: review.facet() },
-                }
-            }
-        }
-    };
-}
-scalar_families!(define_families);
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-pub enum ReferenceCollection {
-    Steps,
-    FragmentBranches,
-    FunctionInputItems,
-    FunctionOutputItems,
-    SignalItems,
-    ExchangeItems,
-    TransitionTriggers,
-    TransitionEffects,
-    Constrained,
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-pub enum OrderedCollection {
-    Steps,
-    FragmentBranches,
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-pub enum IncidentEnd {
-    Source,
-    Target,
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-pub enum ArtifactFacet {
-    Presence,
-    Name,
-    Description,
-    Owner,
-    Relation,
-    Uri,
-    Revision,
-    Fragment,
-}
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub enum ArtifactReview {
-    Presence(Reviewed<bool>),
-    Name(Reviewed<String>),
-    Description(Reviewed<String>),
-    Owner(Reviewed<Id>),
-    Relation(Reviewed<ArtifactRelation>),
-    Uri(Reviewed<String>),
-    Revision(Reviewed<Option<String>>),
-    Fragment(Reviewed<Option<String>>),
-}
-impl ArtifactReview {
-    pub fn facet(&self) -> ArtifactFacet {
-        match self {
-            Self::Presence(_) => ArtifactFacet::Presence,
-            Self::Name(_) => ArtifactFacet::Name,
-            Self::Description(_) => ArtifactFacet::Description,
-            Self::Owner(_) => ArtifactFacet::Owner,
-            Self::Relation(_) => ArtifactFacet::Relation,
-            Self::Uri(_) => ArtifactFacet::Uri,
-            Self::Revision(_) => ArtifactFacet::Revision,
-            Self::Fragment(_) => ArtifactFacet::Fragment,
-        }
-    }
-}
-#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct SemanticBaseline {
-    pub facets: Vec<FacetReview>,
-}

crates/oa-core/src/session.rs

@@ -114,7 +114,6 @@ pub struct PreparedCommand {
 struct IdentityProvenance {
     original: BTreeSet<Id>,
     current_to_original: BTreeMap<Id, Id>,
-    explicit_replacement: bool,
 }
 
 impl IdentityProvenance {
@@ -124,12 +123,10 @@ impl IdentityProvenance {
         Self {
             original,
             current_to_original,
-            explicit_replacement: false,
         }
     }
 
     fn replace(&mut self, project: &Project) {
-        self.explicit_replacement = true;
         let present: BTreeSet<_> = project.identities().into_iter().map(|(id, _)| id).collect();
         self.current_to_original = self
             .original
@@ -183,13 +180,6 @@ pub fn prepare_command(
     )?;
     crate::references::finish_deletions(&mut candidate, &pending_deletions);
     provenance.retain_present(&candidate);
-    if !provenance.explicit_replacement {
-        crate::data::prune_removed_inheritance(
-            project,
-            &mut candidate,
-            &provenance.current_to_original,
-        );
-    }
     validate_candidate(&candidate)?;
     Ok(PreparedCommand {
         project: candidate,
@@ -297,13 +287,6 @@ pub fn execute_batch(project: &Project, commands: &[Command]) -> Result<Project,
         )?;
     }
     crate::references::finish_deletions(&mut candidate, &pending_deletions);
-    if !provenance.explicit_replacement {
-        crate::data::prune_removed_inheritance(
-            project,
-            &mut candidate,
-            &provenance.current_to_original,
-        );
-    }
     validate_candidate(&candidate)?;
     Ok(candidate)
 }

crates/oa-core/src/source_files.rs

@@ -999,7 +999,7 @@ mod transaction_tests {
         let directory = tempfile::tempdir().unwrap();
         fs::write(
             directory.path().join("project.arcadia"),
-            "arcadia 5; project p \"P\" { include \"a.arcadia\"; include \"b.arcadia\"; }",
+            "arcadia 3; project p \"P\" { include \"a.arcadia\"; include \"b.arcadia\"; }",
         )
         .unwrap();
         fs::write(directory.path().join("a.arcadia"), "oa_activity a \"A\" {}").unwrap();

crates/oa-core/src/source_project.rs

@@ -1,11 +1,9 @@
-//! Pure, bounded source projects. All includes resolve against supplied UTF-8
+//! Pure, bounded source3 projects. All includes resolve against supplied UTF-8
 //! documents; this module never reads a filesystem, URL, or process directory.
-use crate::{Id, Kind, Project, SCHEMA_VERSION, language, persistence::DecodeResult, validation};
+use crate::{Id, Kind, Project, language, persistence::DecodeResult, validation};
 use language::{Diagnostic, ParseLimits, Span};
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, BTreeSet};
-#[path = "source_project/source_migration.rs"]
-mod source_migration;
 #[path = "source_project/source_structure.rs"]
 mod source_structure;
 
@@ -280,24 +278,21 @@ pub fn lint_bundle(bundle: &SourceBundle, limits: ProjectLimits) -> Vec<SourceDi
     }
 }
 
-/// Compile reachable source3/4/5 files, explicitly upgrade contracts, and stabilize UUIDs.
+/// Compile all reachable files as one source3 model and stabilize omitted UUIDs.
 /// Missing/unreachable files and every admission or engineering error leave the
 /// input untouched. V1/V2 single-file migration remains in `language::parse`.
 pub fn compile_bundle(
     bundle: &SourceBundle,
     limits: ProjectLimits,
 ) -> Result<CompiledSourceProject, Vec<SourceDiagnostic>> {
-    let (mut compiled, insertions) = compile_once(bundle, limits)?;
-    if !insertions.is_empty() {
-        let mut stable = bundle.clone();
-        apply_edits(&mut stable, insertions)?;
-        // Re-index actual returned bytes before performing the schema upgrade.
-        compiled = compile_once(&stable, limits)?.0;
+    let (compiled, insertions) = compile_once(bundle, limits)?;
+    if insertions.is_empty() {
+        return Ok(compiled);
     }
-    if compiled.decoded.migration.is_some() {
-        return source_migration::upgrade(&compiled, limits);
-    }
-    Ok(compiled)
+    let mut stable = bundle.clone();
+    apply_edits(&mut stable, insertions)?;
+    // Re-index the actual returned bytes. Never expose offsets into pre-ID text.
+    compile_once(&stable, limits).map(|(compiled, _)| compiled)
 }
 
 fn compile_once(
@@ -573,7 +568,7 @@ fn compile_once(
             span,
         }),
     };
-    let decoded =
+    let project =
         language::resolve_declarations(header.project, &declarations, &aliases, limits.model)
             .map_err(|(index, error)| {
                 let path = declaration_paths.get(index).unwrap_or(&bundle.entry);
@@ -583,7 +578,7 @@ fn compile_once(
                     related: Vec::new(),
                 }]
             })?;
-    let diagnostics = model_diagnostics(bundle, &index, &decoded.project);
+    let diagnostics = model_diagnostics(bundle, &index, &project);
     let errors: Vec<_> = diagnostics
         .iter()
         .filter(|issue| issue.diagnostic.severity == validation::Severity::Error)
@@ -595,7 +590,10 @@ fn compile_once(
     Ok((
         CompiledSourceProject {
             bundle: bundle.clone(),
-            decoded,
+            decoded: DecodeResult {
+                project,
+                migration: None,
+            },
             index,
             diagnostics,
         },
@@ -720,7 +718,7 @@ fn apply_edits(bundle: &mut SourceBundle, edits: Edits) -> Result<(), Vec<Source
     Ok(())
 }
 
-/// Canonical, readable current-version export. Like `language::format`, the caller is
+/// Canonical, readable source3 export. Like `language::format`, the caller is
 /// responsible for supplying a valid model; compilation checks the result.
 /// Existing source layout is preserved by `update_bundle`, not this formatter.
 pub fn format_bundle(project: &Project) -> SourceBundle {
@@ -736,7 +734,7 @@ pub fn format_bundle(project: &Project) -> SourceBundle {
             .push_str(&unindent(&declaration));
     }
     let mut entry = format!(
-        "arcadia {SCHEMA_VERSION};\n{}{{\n    description {};\n",
+        "arcadia 3;\n{}{{\n    description {};\n",
         project_header(project),
         quote(&project.description)
     );
@@ -925,8 +923,6 @@ pub fn update_bundle_with_identity_map(
                 after: new_text,
                 old_aliases: &old_aliases,
                 new_aliases: &new_aliases,
-                legacy_value_paths: false,
-                identity_origins: Some(&origins),
             };
             let local = edits.entry(path.clone()).or_default();
             update.header(&actual.header, &previous.header, &next.header, local);
@@ -955,8 +951,6 @@ pub fn update_bundle_with_identity_map(
             after: &after,
             old_aliases: &old_aliases,
             new_aliases: &new_aliases,
-            legacy_value_paths: false,
-            identity_origins: Some(&origins),
         };
         let mut local = Vec::new();
         update.header(
@@ -1125,10 +1119,6 @@ struct SyntaxUpdate<'a> {
     after: &'a str,
     old_aliases: &'a BTreeMap<String, String>,
     new_aliases: &'a BTreeMap<String, String>,
-    // Source3 migration only adds path qualification; the existing field identity
-    // must keep its authored argument trivia during that one-time transformation.
-    legacy_value_paths: bool,
-    identity_origins: Option<&'a BTreeMap<Id, Id>>,
 }
 impl SyntaxUpdate<'_> {
     fn header(
@@ -1224,18 +1214,6 @@ impl SyntaxUpdate<'_> {
                     alias.clone(),
                 ));
             }
-            (EditKind::HistoricalUuid(_), EditKind::HistoricalUuid(id)) => {
-                let token = significant(&self.source[actual.span.start..actual.span.end])
-                    .pop()
-                    .expect("historical UUID string");
-                edits.push((
-                    Span {
-                        start: actual.span.start + token.span.start,
-                        end: actual.span.start + token.span.end,
-                    },
-                    quote(&id.to_string()),
-                ));
-            }
             (EditKind::Atom, EditKind::Atom) => edits.push((
                 actual.span,
                 self.after[after.span.start..after.span.end].into(),
@@ -1360,27 +1338,11 @@ impl SyntaxUpdate<'_> {
         let previous = before.unwrap_or(&[]);
         let old_keys: Option<Vec<_>> = previous
             .iter()
-            .map(|item| {
-                item_key(
-                    item,
-                    self.before,
-                    self.old_aliases,
-                    self.legacy_value_paths,
-                    None,
-                )
-            })
+            .map(|item| item_key(item, self.before, self.old_aliases))
             .collect();
         let new_keys: Option<Vec<_>> = after
             .iter()
-            .map(|item| {
-                item_key(
-                    item,
-                    self.after,
-                    self.new_aliases,
-                    self.legacy_value_paths,
-                    self.identity_origins,
-                )
-            })
+            .map(|item| item_key(item, self.after, self.new_aliases))
             .collect();
         let keyed = old_keys.zip(new_keys).filter(|(old, new)| {
             old.iter().collect::<BTreeSet<_>>().len() == old.len()
@@ -1487,23 +1449,9 @@ fn item_key(
     value: &language::EditValue,
     source: &str,
     aliases: &BTreeMap<String, String>,
-    legacy_value_paths: bool,
-    origins: Option<&BTreeMap<Id, Id>>,
 ) -> Option<String> {
     use language::EditKind;
-    if matches!(value.kind, EditKind::Record(_))
-        && let Some(key) = language::semantic_row_key(
-            &source[value.span.start..value.span.end],
-            origins.unwrap_or(&BTreeMap::new()),
-        )
-    {
-        return Some(key);
-    }
     match &value.kind {
-        EditKind::HistoricalUuid(id) => Some(format!(
-            "uuid:{}",
-            origins.and_then(|map| map.get(id)).unwrap_or(id)
-        )),
         EditKind::Reference(alias) => aliases.get(alias).map(|id| format!("ref:{id}")),
         EditKind::Atom => Some(format!(
             "literal:{}",
@@ -1514,31 +1462,7 @@ fn item_key(
             .find_map(|key| {
                 fields.get(key).and_then(|field| {
                     if let EditKind::Reference(alias) = &field.value.kind {
-                        aliases.get(alias).map(|id| {
-                            if key == "field" && !legacy_value_paths {
-                                let path = fields
-                                    .get("path")
-                                    .and_then(|field| {
-                                        if let EditKind::List(path) = &field.value.kind {
-                                            path.iter()
-                                                .map(|hop| {
-                                                    if let EditKind::Reference(alias) = &hop.kind {
-                                                        aliases.get(alias).cloned()
-                                                    } else {
-                                                        None
-                                                    }
-                                                })
-                                                .collect::<Option<Vec<_>>>()
-                                        } else {
-                                            None
-                                        }
-                                    })
-                                    .unwrap_or_default();
-                                format!("field:{}:{id}", path.join("/"))
-                            } else {
-                                format!("{key}:{id}")
-                            }
-                        })
+                        aliases.get(alias).map(|id| format!("{key}:{id}"))
                     } else {
                         None
                     }

crates/oa-core/src/source_project/source_migration.rs

@@ -1,127 +0,0 @@
-//! Source3/4 upgrade through token edits; authored modules, nesting and trivia survive.
-use super::*;
-
-pub(super) fn upgrade(
-    current: &CompiledSourceProject,
-    limits: ProjectLimits,
-) -> Result<CompiledSourceProject, Vec<SourceDiagnostic>> {
-    let report = current
-        .decoded
-        .migration
-        .as_ref()
-        .expect("an explicit source migration report");
-    let project = &current.decoded.project;
-    let canonical: BTreeMap<_, _> = language::format_declarations(project).into_iter().collect();
-    let changed: BTreeSet<_> = report
-        .semantic_defaults
-        .iter()
-        .filter(|default| default.field != "baseline.semantic")
-        .map(|default| default.object)
-        .collect();
-    let aliases: BTreeMap<_, _> = project
-        .identities()
-        .into_iter()
-        .map(|(id, alias)| (alias.to_owned(), id.to_string()))
-        .collect();
-    let mut edits: Edits = BTreeMap::new();
-    for (path, source) in &current.bundle.files {
-        let declarations =
-            language::edit_declarations(source, path == &current.bundle.entry, limits.model)
-                .map_err(|diagnostic| {
-                    vec![SourceDiagnostic {
-                        path: path.clone(),
-                        diagnostic: *diagnostic,
-                        related: vec![],
-                    }]
-                })?;
-        for (id, actual) in declarations {
-            if !changed.contains(&id) {
-                continue;
-            }
-            let Some(after) = canonical.get(&id) else {
-                continue;
-            };
-            let mut next = language::edit_declaration(after).map_err(|diagnostic| {
-                vec![SourceDiagnostic {
-                    path: path.clone(),
-                    diagnostic: *diagnostic,
-                    related: vec![],
-                }]
-            })?;
-            if actual.lexical_owner.is_some()
-                && let language::EditKind::Record(fields) = &actual.fields.kind
-                && !fields.contains_key("parent")
-                && let language::EditKind::Record(fields) = &mut next.fields.kind
-            {
-                fields.remove("parent");
-            }
-            let update = SyntaxUpdate {
-                source,
-                before: source,
-                after,
-                old_aliases: &aliases,
-                new_aliases: &aliases,
-                legacy_value_paths: true,
-                identity_origins: None,
-            };
-            update.value(
-                &actual.fields,
-                Some(&actual.fields),
-                &next.fields,
-                edits.entry(path.clone()).or_default(),
-            );
-        }
-    }
-    let source = &current.bundle.files[&current.bundle.entry];
-    let version = significant(source)
-        .get(1)
-        .map(|token| token.span)
-        .expect("a parsed version token");
-    edits
-        .entry(current.bundle.entry.clone())
-        .or_default()
-        .push((version, crate::SCHEMA_VERSION.to_string()));
-    // New allocation relations are emitted into the allocating interface's
-    // existing module, outside its lexical element body. Existing source never moves.
-    let mut added: BTreeMap<String, String> = BTreeMap::new();
-    for allocation in &report.generated_interface_allocations {
-        let path = current
-            .index
-            .declarations
-            .get(&allocation.source)
-            .map(|location| location.path.clone())
-            .unwrap_or_else(|| current.bundle.entry.clone());
-        let ending = newline(&current.bundle.files[&path]);
-        let text = added.entry(path).or_default();
-        text.push_str(ending);
-        text.push_str(&canonical[&allocation.id].replace('\n', ending));
-    }
-    for (path, text) in added {
-        let offset = if path == current.bundle.entry {
-            current.index.project_body.span.end
-        } else {
-            current.bundle.files[&path].len()
-        };
-        edits.entry(path).or_default().push((
-            Span {
-                start: offset,
-                end: offset,
-            },
-            text,
-        ));
-    }
-    let mut bundle = current.bundle.clone();
-    apply_edits(&mut bundle, edits)?;
-    let (mut result, insertions) = compile_once(&bundle, limits)?;
-    if !insertions.is_empty() || result.decoded.project != *project {
-        return Err(vec![problem(
-            &bundle,
-            &bundle.entry,
-            Span::default(),
-            "migration_source_mismatch",
-            "Targeted source upgrade did not reproduce the migrated project.",
-        )]);
-    }
-    result.decoded.migration = Some(report.clone());
-    Ok(result)
-}

crates/oa-core/src/transitions.rs

@@ -202,15 +202,9 @@ fn mapped_body(e: &Element, kind: Kind, layer: Layer) -> Option<ElementBody> {
         return None;
     }
     if let Some(shared) = e.shared()
-        && (kind == e.kind() || (kind.is_state() && e.kind().is_state()))
+        && kind == e.kind()
     {
         let mut shared = shared.clone();
-        if let SharedBody::State {
-            kind: state_kind, ..
-        } = &mut shared
-        {
-            *state_kind = kind.state_kind()?;
-        }
         if let SharedBody::Scenario { viewpoint, .. } = &mut shared {
             *viewpoint = match (*viewpoint, layer) {
                 (ScenarioViewpoint::OperationalActivity, Layer::Sa) => {
@@ -257,8 +251,6 @@ fn mapped_relation(r: &Relation, direction: TransitionDirection) -> Option<Relat
         }
         (
             RelationBody::Allocation { .. }
-            | RelationBody::InterfaceItemAllocation { .. }
-            | RelationBody::DataAssociation { .. }
             | RelationBody::ExchangeAllocation { .. }
             | RelationBody::CapabilityInvolvement { .. }
             | RelationBody::CapabilityInclude { .. }
@@ -395,30 +387,11 @@ pub fn plan_transition(
         commands: vec![],
     };
     let mut selected: BTreeSet<_> = request.sources.iter().copied().collect();
-    let mut omitted = if request.direction == TransitionDirection::SaToOa {
+    let omitted = if request.direction == TransitionDirection::SaToOa {
         sa_port_omissions(project)
     } else {
         BTreeSet::new()
     };
-    // An explicit existing Legacy counterpart can be compared and reviewed
-    // without inventing an OA typed port. Only this port is retained: dependent
-    // SA implementation records and new counterpart requests stay omitted.
-    for mapping in &request.mappings {
-        if project
-            .elements
-            .get(&mapping.source)
-            .is_some_and(|e| e.layer() == Layer::Sa && crate::ports::port_contract(e).is_some())
-            && mapping
-                .target
-                .and_then(|target| project.elements.get(&target))
-                .is_some_and(|e| {
-                    e.layer() == Layer::Oa
-                        && crate::ports::port_contract(e) == Some(&PortContract::Legacy)
-                })
-        {
-            omitted.remove(&mapping.source);
-        }
-    }
     let mut reported_omissions = BTreeSet::new();
     if selected.len() != request.sources.len() {
         conflict(
@@ -448,24 +421,6 @@ pub fn plan_transition(
                 }
                 if let Some(e) = project.elements.get(&id) {
                     selected.extend(crate::references::element_references(e));
-                    // Allocations are owned by interfaces. Independent data
-                    // associations travel only when both endpoint types are
-                    // already required; they do not expand the dictionary.
-                    if matches!(e.kind(), Kind::Interface | Kind::DataType) {
-                        let contracts: Vec<_> = project
-                            .relations
-                            .values()
-                            .filter_map(|r| {
-                                ((r.kind() == RelationKind::InterfaceItemAllocation
-                                    && r.source() == id)
-                                    || (r.kind() == RelationKind::DataAssociation
-                                        && selected.contains(&r.source())
-                                        && selected.contains(&r.target())))
-                                .then_some(r.id)
-                            })
-                            .collect();
-                        selected.extend(contracts);
-                    }
                     // Contextual links are owned by the process/chain shared by
                     // their endpoint involvements, independently of list order.
                     if matches!(e.kind(), Kind::Process | Kind::FunctionalChain) {
@@ -952,7 +907,6 @@ pub fn plan_transition(
                 .unwrap_or(TraceBaseline {
                     oa: current_oa.clone(),
                     sa: current_sa.clone(),
-                    semantic: None,
                 });
         for field in &reviewed_fields {
             set(&mut baseline.oa, *field, value(&current_oa, *field).clone());
@@ -1107,11 +1061,6 @@ pub fn counterpart_kinds(source: Kind, direction: TransitionDirection) -> Vec<Ki
 }
 
 fn compatible_kinds(source: Kind, target: Kind, direction: TransitionDirection) -> bool {
-    // State kind is a reviewed structural facet of one state family. An existing
-    // counterpart remains selectable after either side changes its vertex kind.
-    if source.is_state() && target.is_state() {
-        return true;
-    }
     if matches!(
         (direction, source, target),
         (

crates/oa-core/src/validation.rs

@@ -388,10 +388,68 @@ pub fn validate(p: &Project) -> Vec<Issue> {
         }
         if let Some(shared) = e.shared() {
             match shared {
-                SharedBody::DataType { .. }
-                | SharedBody::DataField { .. }
-                | SharedBody::Interface { .. }
-                | SharedBody::ExchangeItem { .. } => crate::data::validate_element(p, e, &mut out),
+                SharedBody::DataType {
+                    definition: DataTypeDefinition::Enumeration { literals },
+                } => {
+                    let mut seen = BTreeSet::new();
+                    for literal in literals {
+                        text(&mut out, e.id, "literals", literal);
+                        if !seen.insert(literal) {
+                            error(
+                                &mut out,
+                                e.id,
+                                "duplicate_literal",
+                                "literals",
+                                "Enumeration literals must be unique.",
+                            );
+                        }
+                    }
+                }
+                SharedBody::DataField {
+                    type_ref,
+                    minimum,
+                    maximum,
+                    unit,
+                } => {
+                    if maximum.is_some_and(|max| max < *minimum) {
+                        error(
+                            &mut out,
+                            e.id,
+                            "invalid_multiplicity",
+                            "maximum",
+                            "Maximum multiplicity must be at least minimum, or unbounded.",
+                        );
+                    }
+                    text(&mut out, e.id, "unit", unit);
+                    if let TypeRef::Named(id) = type_ref {
+                        expect_element(p, &mut out, e.id, *id, "type_ref", |k| k == Kind::DataType);
+                    }
+                    if let Some(parent) = e.parent.and_then(|id| p.elements.get(&id))
+                        && parent.kind() == Kind::DataType
+                        && !matches!(
+                            parent.shared(),
+                            Some(SharedBody::DataType {
+                                definition: DataTypeDefinition::Record
+                            })
+                        )
+                    {
+                        error(
+                            &mut out,
+                            e.id,
+                            "field_owner",
+                            "parent",
+                            "Fields under a data type require a Record type.",
+                        );
+                    }
+                }
+                SharedBody::Interface { items } => {
+                    check_ids(&mut out, e.id, "items", items);
+                    for id in items {
+                        expect_element(p, &mut out, e.id, *id, "items", |k| {
+                            k == Kind::ExchangeItem
+                        });
+                    }
+                }
                 SharedBody::Port { .. } => crate::ports::validate_port(p, e, &mut out),
                 SharedBody::Scenario {
                     viewpoint,
@@ -585,11 +643,9 @@ pub fn validate(p: &Project) -> Vec<Issue> {
         text(&mut out, r.id, "name", &r.name);
         text(&mut out, r.id, "description", &r.description);
         validate_relation(p, r, &mut out);
-        crate::data::validate_relation(p, r, &mut out);
         crate::ports::validate_boundary_interface_requirements(p, r, &mut out);
         validate_relation_context(p, r, &mut out);
     }
-    crate::data::validate_record_cycles(p, &mut out);
     for (key, d) in &p.diagrams {
         if *key != d.id {
             error(
@@ -876,19 +932,6 @@ pub fn validate(p: &Project) -> Vec<Issue> {
                 text(&mut out, t.id, "baseline.name", &props.name);
                 text(&mut out, t.id, "baseline.description", &props.description);
             }
-            if let Some(semantic) = &b.semantic
-                && let Err(errors) = crate::semantic::validate_semantic_baseline(semantic)
-            {
-                for message in errors {
-                    error(
-                        &mut out,
-                        t.id,
-                        "semantic_baseline",
-                        "baseline.semantic",
-                        message,
-                    );
-                }
-            }
         }
         match crate::transitions::trace_drift(p, t) {
             crate::transitions::Drift::Unchanged => {}
@@ -1393,10 +1436,23 @@ fn enclosing_loops(p: &Project, occurrence: Id) -> BTreeSet<Id> {
 }
 /// Fields carried by an exchange, including fields of nested named records.
 pub fn carried_fields(p: &Project, relation: &Relation) -> BTreeSet<Id> {
-    crate::data::carried_field_paths(p, relation)
-        .into_iter()
-        .map(|f| f.field)
-        .collect()
+    let mut pending = relation.body.items().to_vec();
+    let mut seen = BTreeSet::new();
+    let mut fields = BTreeSet::new();
+    while let Some(owner) = pending.pop() {
+        if !seen.insert(owner) {
+            continue;
+        }
+        for field in p.children(owner) {
+            if let Some(SharedBody::DataField { type_ref, .. }) = field.shared() {
+                fields.insert(field.id);
+                if let TypeRef::Named(id) = type_ref {
+                    pending.push(*id);
+                }
+            }
+        }
+    }
+    fields
 }
 fn occurrence_uses_lifeline(body: &OccurrenceBody, line: Id) -> bool {
     match body {
@@ -1627,125 +1683,36 @@ fn validate_message(p: &Project, e: &Element, body: &OccurrenceBody, out: &mut V
             }
         }
     }
-    let relation = exchange.and_then(|id| p.relations.get(&id));
-    if message_kind == &MessageKind::Call
-        && relation.is_some_and(|r| {
-            !r.body
-                .items()
-                .iter()
-                .any(|id| crate::data::item_mechanism(p, *id) == Some(ExchangeMechanism::Operation))
-        })
-    {
-        warning(
-            out,
-            e.id,
-            "call_without_operation",
-            "exchange",
-            "This generic call carries no Operation item; define an operation contract when appropriate.",
-        );
-    }
+    let allowed = exchange
+        .and_then(|id| p.relations.get(&id))
+        .map(|r| carried_fields(p, r));
     let mut fields = BTreeSet::new();
     for value in values {
         expect_element(p, out, e.id, value.field, "values.field", |kind| {
             kind == Kind::DataField
         });
-        for hop in &value.path {
-            expect_element(p, out, e.id, *hop, "values.path", |kind| {
-                kind == Kind::DataField
-            });
-        }
         text(out, e.id, "values.expression", &value.expression);
-        if !fields.insert((&value.path, value.field)) {
+        if !fields.insert(value.field) {
             error(
                 out,
                 e.id,
                 "duplicate_message_value",
                 "values",
-                "Each qualified carried field has at most one contextual value annotation.",
+                "Each carried field has at most one contextual value annotation in a message.",
             );
         }
-        if value.path.len() > crate::data::MAX_VALUE_PATH_DEPTH {
+        if allowed
+            .as_ref()
+            .is_some_and(|allowed| !allowed.contains(&value.field))
+        {
             error(
                 out,
                 e.id,
-                "message_value_path_limit",
-                "values.path",
-                "The value path exceeds the bounded authoring depth.",
+                "message_value_field",
+                "values.field",
+                "Value annotations must reference fields carried by this message's exchange, including nested record fields.",
             );
         }
-        if let Some(r) = relation {
-            if let Some(path) = crate::data::carried_value_path(p, r, &value.path, value.field) {
-                if crate::data::item_mechanism(p, path.item) == Some(ExchangeMechanism::Operation) {
-                    let permitted = match message_kind {
-                        MessageKind::Call => matches!(
-                            path.direction,
-                            ParameterDirection::Unspecified
-                                | ParameterDirection::In
-                                | ParameterDirection::InOut
-                        ),
-                        MessageKind::Reply => matches!(
-                            path.direction,
-                            ParameterDirection::Unspecified
-                                | ParameterDirection::Out
-                                | ParameterDirection::InOut
-                                | ParameterDirection::Return
-                        ),
-                        _ => true,
-                    };
-                    if !permitted {
-                        error(
-                            out,
-                            e.id,
-                            "message_parameter_phase",
-                            "values.path",
-                            "Call values address In/InOut parameters; replies address Out/InOut/Return parameters.",
-                        );
-                    }
-                    if path.direction == ParameterDirection::Unspecified {
-                        warning(
-                            out,
-                            e.id,
-                            "message_parameter_direction",
-                            "values.path",
-                            "The containing operation parameter has no direction yet.",
-                        );
-                    }
-                }
-            } else {
-                let legacy = value
-                    .path
-                    .is_empty()
-                    .then(|| crate::data::resolve_legacy_field_path(p, r, value.field).ok())
-                    .flatten();
-                if matches!(
-                    legacy,
-                    Some(
-                        crate::data::LegacyFieldPathResolution::Unique(_)
-                            | crate::data::LegacyFieldPathResolution::Ambiguous
-                    )
-                ) {
-                    warning(
-                        out,
-                        e.id,
-                        if legacy == Some(crate::data::LegacyFieldPathResolution::Ambiguous) {
-                            "message_value_ambiguous_path"
-                        } else {
-                            "message_value_missing_path"
-                        },
-                        "values.path",
-                        "This legacy nested field annotation needs an explicit containing parameter path; its expression is preserved.",
-                    );
-                } else {
-                    error(
-                        out,
-                        e.id,
-                        "message_value_field",
-                        "values.path",
-                        "The qualified field must be carried by the exchange, following Value record fields only.",
-                    );
-                }
-            }
-        }
         if value.expression.trim().is_empty() {
             warning(
                 out,
@@ -2163,11 +2130,7 @@ fn validate_relation(p: &Project, r: &Relation, out: &mut Vec<Issue>) {
     };
     if a.layer() != b.layer()
         || !r.kind().permits(a.kind(), b.kind())
-        || (a.id == b.id
-            && !matches!(
-                r.kind(),
-                RelationKind::StateTransition | RelationKind::DataAssociation
-            ))
+        || (a.id == b.id && r.kind() != RelationKind::StateTransition)
     {
         error(
             out,
@@ -2418,10 +2381,8 @@ pub fn can_parent(p: &Project, child_kind: Kind, layer: Layer, parent: Option<Id
             owner.layer() == layer
                 && parent_permits(owner.kind(), child_kind)
                 && match owner.shared() {
-                    Some(SharedBody::DataType { definition, .. })
-                        if child_kind == Kind::DataField =>
-                    {
-                        matches!(definition, DataTypeDefinition::Record { .. })
+                    Some(SharedBody::DataType { definition }) if child_kind == Kind::DataField => {
+                        *definition == DataTypeDefinition::Record
                     }
                     Some(SharedBody::Occurrence { body, .. }) if child_kind == Kind::Occurrence => {
                         matches!(

crates/oa-core/tests/fixtures/v3-data-contract.arcadia

@@ -1,38 +0,0 @@
-// Frozen authored schema3 compatibility input. Do not rewrite as current syntax.
-arcadia 3;
-project legacy_data "Legacy data contract" id "00000000-0000-0000-0000-000000000001" {
-    sa_function produce "Produce" id "00000000-0000-0000-0000-000000000002" {}
-    sa_function consume "Consume" id "00000000-0000-0000-0000-000000000003" {}
-    sa_exchange_item packet "Position event" id "00000000-0000-0000-0000-000000000004" {
-        kind Event;
-        // Reused record parameters retain their own identities.
-        sa_data_field origin "Origin" id "00000000-0000-0000-0000-000000000007" { type_ref { Named @coordinate; }; }
-        sa_data_field destination "Destination" id "00000000-0000-0000-0000-000000000008" { type_ref { Named @coordinate; }; }
-    }
-    sa_data_type coordinate "Coordinate" id "00000000-0000-0000-0000-000000000005" {
-        definition Record;
-        sa_data_field latitude "Latitude" id "00000000-0000-0000-0000-000000000006" { type_ref Real; unit "deg"; }
-    }
-    sa_interface sender_contract "Sender contract" id "00000000-0000-0000-0000-000000000009" { items [@packet]; }
-    sa_interface receiver_contract "Receiver contract" id "00000000-0000-0000-0000-00000000000a" { items [@packet]; }
-    sa_port output "Output" id "00000000-0000-0000-0000-00000000000b" {
-        parent @produce; contract { FunctionOutput { outgoing_items [@packet]; }; }; legacy none;
-    }
-    sa_port input "Input" id "00000000-0000-0000-0000-00000000000c" {
-        parent @consume; contract { FunctionInput { incoming_items [@packet]; }; }; legacy none;
-    }
-    functional_exchange position_exchange "Position exchange" id "00000000-0000-0000-0000-00000000000d" {
-        source @produce; target @consume; source_port @output; target_port @input; items [@packet];
-    }
-    sa_scenario scenario "Position scenario" id "00000000-0000-0000-0000-00000000000e" {
-        viewpoint Functional; steps [@message];
-        sa_lifeline sender "Sender" id "00000000-0000-0000-0000-00000000000f" { represented @produce; }
-        sa_lifeline receiver "Receiver" id "00000000-0000-0000-0000-000000000010" { represented @consume; }
-        sa_occurrence message "Position" id "00000000-0000-0000-0000-000000000011" {
-            body { Exchange {
-                exchange @position_exchange; sender @sender; receiver @receiver;
-                values [{ field @latitude; expression "navigation.latitude"; }];
-            }; };
-        }
-    }
-}

crates/oa-core/tests/fixtures/v3-data-contract.json

@@ -1,312 +0,0 @@
-{
-  "schema_version": 3,
-  "id": "00000000-0000-0000-0000-000000000001",
-  "alias": "legacy_data",
-  "name": "Legacy data contract",
-  "description": "",
-  "elements": {
-    "00000000-0000-0000-0000-000000000002": {
-      "id": "00000000-0000-0000-0000-000000000002",
-      "alias": "produce",
-      "name": "Produce",
-      "description": "",
-      "parent": null,
-      "body": {
-        "Sa": "Function"
-      }
-    },
-    "00000000-0000-0000-0000-000000000003": {
-      "id": "00000000-0000-0000-0000-000000000003",
-      "alias": "consume",
-      "name": "Consume",
-      "description": "",
-      "parent": null,
-      "body": {
-        "Sa": "Function"
-      }
-    },
-    "00000000-0000-0000-0000-000000000004": {
-      "id": "00000000-0000-0000-0000-000000000004",
-      "alias": "packet",
-      "name": "Position event",
-      "description": "",
-      "parent": null,
-      "body": {
-        "Sa": {
-          "Shared": {
-            "ExchangeItem": {
-              "kind": "Event"
-            }
-          }
-        }
-      }
-    },
-    "00000000-0000-0000-0000-000000000005": {
-      "id": "00000000-0000-0000-0000-000000000005",
-      "alias": "coordinate",
-      "name": "Coordinate",
-      "description": "",
-      "parent": null,
-      "body": {
-        "Sa": {
-          "Shared": {
-            "DataType": {
-              "definition": "Record"
-            }
-          }
-        }
-      }
-    },
-    "00000000-0000-0000-0000-000000000006": {
-      "id": "00000000-0000-0000-0000-000000000006",
-      "alias": "latitude",
-      "name": "Latitude",
-      "description": "",
-      "parent": "00000000-0000-0000-0000-000000000005",
-      "body": {
-        "Sa": {
-          "Shared": {
-            "DataField": {
-              "type_ref": "Real",
-              "minimum": 1,
-              "maximum": 1,
-              "unit": "deg"
-            }
-          }
-        }
-      }
-    },
-    "00000000-0000-0000-0000-000000000007": {
-      "id": "00000000-0000-0000-0000-000000000007",
-      "alias": "origin",
-      "name": "Origin",
-      "description": "",
-      "parent": "00000000-0000-0000-0000-000000000004",
-      "body": {
-        "Sa": {
-          "Shared": {
-            "DataField": {
-              "type_ref": {
-                "Named": "00000000-0000-0000-0000-000000000005"
-              },
-              "minimum": 1,
-              "maximum": 1,
-              "unit": ""
-            }
-          }
-        }
-      }
-    },
-    "00000000-0000-0000-0000-000000000008": {
-      "id": "00000000-0000-0000-0000-000000000008",
-      "alias": "destination",
-      "name": "Destination",
-      "description": "",
-      "parent": "00000000-0000-0000-0000-000000000004",
-      "body": {
-        "Sa": {
-          "Shared": {
-            "DataField": {
-              "type_ref": {
-                "Named": "00000000-0000-0000-0000-000000000005"
-              },
-              "minimum": 1,
-              "maximum": 1,
-              "unit": ""
-            }
-          }
-        }
-      }
-    },
-    "00000000-0000-0000-0000-000000000009": {
-      "id": "00000000-0000-0000-0000-000000000009",
-      "alias": "sender_contract",
-      "name": "Sender contract",
-      "description": "",
-      "parent": null,
-      "body": {
-        "Sa": {
-          "Shared": {
-            "Interface": {
-              "items": [
-                "00000000-0000-0000-0000-000000000004"
-              ]
-            }
-          }
-        }
-      }
-    },
-    "00000000-0000-0000-0000-00000000000a": {
-      "id": "00000000-0000-0000-0000-00000000000a",
-      "alias": "receiver_contract",
-      "name": "Receiver contract",
-      "description": "",
-      "parent": null,
-      "body": {
-        "Sa": {
-          "Shared": {
-            "Interface": {
-              "items": [
-                "00000000-0000-0000-0000-000000000004"
-              ]
-            }
-          }
-        }
-      }
-    },
-    "00000000-0000-0000-0000-00000000000b": {
-      "id": "00000000-0000-0000-0000-00000000000b",
-      "alias": "output",
-      "name": "Output",
-      "description": "",
-      "parent": "00000000-0000-0000-0000-000000000002",
-      "body": {
-        "Sa": {
-          "Shared": {
-            "Port": {
-              "contract": {
-                "FunctionOutput": {
-                  "outgoing_items": [
-                    "00000000-0000-0000-0000-000000000004"
-                  ]
-                }
-              },
-              "legacy": null
-            }
-          }
-        }
-      }
-    },
-    "00000000-0000-0000-0000-00000000000c": {
-      "id": "00000000-0000-0000-0000-00000000000c",
-      "alias": "input",
-      "name": "Input",
-      "description": "",
-      "parent": "00000000-0000-0000-0000-000000000003",
-      "body": {
-        "Sa": {
-          "Shared": {
-            "Port": {
-              "contract": {
-                "FunctionInput": {
-                  "incoming_items": [
-                    "00000000-0000-0000-0000-000000000004"
-                  ]
-                }
-              },
-              "legacy": null
-            }
-          }
-        }
-      }
-    },
-    "00000000-0000-0000-0000-00000000000e": {
-      "id": "00000000-0000-0000-0000-00000000000e",
-      "alias": "scenario",
-      "name": "Position scenario",
-      "description": "",
-      "parent": null,
-      "body": {
-        "Sa": {
-          "Shared": {
-            "Scenario": {
-              "viewpoint": "Functional",
-              "context": null,
-              "precondition": "",
-              "postcondition": "",
-              "steps": [
-                "00000000-0000-0000-0000-000000000011"
-              ]
-            }
-          }
-        }
-      }
-    },
-    "00000000-0000-0000-0000-00000000000f": {
-      "id": "00000000-0000-0000-0000-00000000000f",
-      "alias": "sender",
-      "name": "Sender",
-      "description": "",
-      "parent": "00000000-0000-0000-0000-00000000000e",
-      "body": {
-        "Sa": {
-          "Shared": {
-            "Lifeline": {
-              "represented": "00000000-0000-0000-0000-000000000002"
-            }
-          }
-        }
-      }
-    },
-    "00000000-0000-0000-0000-000000000010": {
-      "id": "00000000-0000-0000-0000-000000000010",
-      "alias": "receiver",
-      "name": "Receiver",
-      "description": "",
-      "parent": "00000000-0000-0000-0000-00000000000e",
-      "body": {
-        "Sa": {
-          "Shared": {
-            "Lifeline": {
-              "represented": "00000000-0000-0000-0000-000000000003"
-            }
-          }
-        }
-      }
-    },
-    "00000000-0000-0000-0000-000000000011": {
-      "id": "00000000-0000-0000-0000-000000000011",
-      "alias": "message",
-      "name": "Position",
-      "description": "",
-      "parent": "00000000-0000-0000-0000-00000000000e",
-      "body": {
-        "Sa": {
-          "Shared": {
-            "Occurrence": {
-              "body": {
-                "Exchange": {
-                  "exchange": "00000000-0000-0000-0000-00000000000d",
-                  "sender": "00000000-0000-0000-0000-00000000000f",
-                  "receiver": "00000000-0000-0000-0000-000000000010",
-                  "message_kind": "Asynchronous",
-                  "reply_to": null,
-                  "values": [
-                    {
-                      "field": "00000000-0000-0000-0000-000000000006",
-                      "expression": "navigation.latitude"
-                    }
-                  ]
-                }
-              },
-              "precondition": "",
-              "postcondition": ""
-            }
-          }
-        }
-      }
-    }
-  },
-  "relations": {
-    "00000000-0000-0000-0000-00000000000d": {
-      "id": "00000000-0000-0000-0000-00000000000d",
-      "alias": "position_exchange",
-      "name": "Position exchange",
-      "description": "",
-      "body": {
-        "FunctionalExchange": {
-          "source": "00000000-0000-0000-0000-000000000002",
-          "target": "00000000-0000-0000-0000-000000000003",
-          "source_port": "00000000-0000-0000-0000-00000000000b",
-          "target_port": "00000000-0000-0000-0000-00000000000c",
-          "items": [
-            "00000000-0000-0000-0000-000000000004"
-          ]
-        }
-      }
-    }
-  },
-  "diagrams": {},
-  "artifact_links": {},
-  "traces": {}
-}

crates/oa-core/tests/fixtures/v4-reviewed-prose.arcadia

@@ -1,27 +0,0 @@
-// Frozen schema4 input: reviewed prose is deliberately different from live prose.
-arcadia 4;
-project reviewed_prose "Reviewed dimensions" id "40000000-0000-4000-8000-000000000001" {
-    description "Preserve the original review without inventing semantic history.";
-    oa_data_type oa_dimension "OA dimension now" id "40000000-0000-4000-8000-000000000002" {
-        description "Unreviewed OA description";
-        definition { Integer { minimum 0; maximum 100; }; };
-        default { Integer 20; };
-        unit "m";
-    }
-    sa_data_type sa_dimension "SA dimension now" id "40000000-0000-4000-8000-000000000003" {
-        description "Unreviewed SA description";
-        definition { Real { minimum 0.0; maximum 100.0; }; };
-        default { Real 20.0; };
-        unit "ft";
-    }
-    trace dimension_review "Dimension rationale" id "40000000-0000-4000-8000-000000000004" {
-        description "The target unit and representation are intentional.";
-        oa @oa_dimension;
-        sa @sa_dimension;
-        kind Item;
-        baseline {
-            oa { name "Approved OA name"; description "Approved OA\nprose"; };
-            sa { name "Approved SA name"; description "Approved SA prose"; };
-        };
-    }
-}

crates/oa-core/tests/fixtures/v4-reviewed-prose.json

@@ -1,51 +0,0 @@
-{
-  "schema_version": 4,
-  "id": "40000000-0000-4000-8000-000000000001",
-  "alias": "reviewed_prose",
-  "name": "Reviewed dimensions",
-  "description": "Preserve the original review without inventing semantic history.",
-  "elements": {
-    "40000000-0000-4000-8000-000000000002": {
-      "id": "40000000-0000-4000-8000-000000000002",
-      "alias": "oa_dimension",
-      "name": "OA dimension now",
-      "description": "Unreviewed OA description",
-      "parent": null,
-      "body": {"Oa": {"Shared": {"DataType": {
-        "definition": {"Integer": {"minimum": 0, "maximum": 100}},
-        "default": {"Integer": 20},
-        "unit": "m"
-      }}}}
-    },
-    "40000000-0000-4000-8000-000000000003": {
-      "id": "40000000-0000-4000-8000-000000000003",
-      "alias": "sa_dimension",
-      "name": "SA dimension now",
-      "description": "Unreviewed SA description",
-      "parent": null,
-      "body": {"Sa": {"Shared": {"DataType": {
-        "definition": {"Real": {"minimum": 0.0, "maximum": 100.0}},
-        "default": {"Real": 20.0},
-        "unit": "ft"
-      }}}}
-    }
-  },
-  "relations": {},
-  "diagrams": {},
-  "artifact_links": {},
-  "traces": {
-    "40000000-0000-4000-8000-000000000004": {
-      "id": "40000000-0000-4000-8000-000000000004",
-      "alias": "dimension_review",
-      "name": "Dimension rationale",
-      "description": "The target unit and representation are intentional.",
-      "oa": "40000000-0000-4000-8000-000000000002",
-      "sa": "40000000-0000-4000-8000-000000000003",
-      "kind": "Item",
-      "baseline": {
-        "oa": {"name": "Approved OA name", "description": "Approved OA\nprose"},
-        "sa": {"name": "Approved SA name", "description": "Approved SA prose"}
-      }
-    }
-  }
-}

crates/oa-core/tests/language.rs

@@ -168,20 +168,6 @@ project mission "Harbor safety — 港 🌊" {
         .find(|e| e.alias == "event_record")
         .unwrap()
         .id;
-    let associated = p
-        .add_element(Kind::DataType, Layer::Sa, "Associated record", None)
-        .unwrap();
-    if let Some(SharedBody::DataType { definition, .. }) =
-        p.elements.get_mut(&associated).unwrap().shared_mut()
-    {
-        *definition = DataTypeDefinition::Record { supertype: None };
-    }
-    p.relate(
-        RelationKind::DataAssociation,
-        "Related record",
-        record,
-        associated,
-    );
     for (index, type_ref) in [
         TypeRef::Boolean,
         TypeRef::Integer,
@@ -204,30 +190,18 @@ project mission "Harbor safety — 港 🌊" {
             minimum: 1,
             maximum: Some(5),
             unit: "unit".into(),
-            direction: ParameterDirection::Unspecified,
-            storage: FieldStorage::Value,
-            default: None,
         };
     }
     for definition in [
         DataTypeDefinition::Boolean,
-        DataTypeDefinition::Integer {
-            minimum: None,
-            maximum: None,
-        },
-        DataTypeDefinition::String {
-            minimum_length: 0,
-            maximum_length: None,
-        },
+        DataTypeDefinition::Integer,
+        DataTypeDefinition::String,
     ] {
         let id = p
             .add_element(Kind::DataType, Layer::Sa, "Primitive type", None)
             .unwrap();
-        *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::DataType {
-            definition,
-            default: None,
-            unit: String::new(),
-        };
+        *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() =
+            SharedBody::DataType { definition };
     }
     for kind in [
         ExchangeItemKind::Material,
@@ -242,11 +216,7 @@ project mission "Harbor safety — 港 🌊" {
                 None,
             )
             .unwrap();
-        *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::ExchangeItem {
-            kind,
-            mechanism: ExchangeMechanism::Unspecified,
-            supertype: None,
-        };
+        *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::ExchangeItem { kind };
     }
     let scenario = p
         .elements
@@ -491,7 +461,7 @@ fn authoring_defaults_and_forward_references_remain_strict() {
 #[test]
 fn typed_unknown_fields_enums_duplicates_and_reference_spelling_are_rejected() {
     for (source, expected) in [
-        ("arcadia 6; project mission \"x\" {}", "Unsupported schema"),
+        ("arcadia 4; project mission \"x\" {}", "Unsupported schema"),
         (
             "arcadia 2; project mission \"x\" { oa_activity a \"A\" { nonsense 1; } }",
             "Unknown field",
@@ -795,27 +765,9 @@ fn original_v2_text_and_json_preserve_identity_and_mixed_scenarios_after_extensi
     assert_eq!(from_source, from_json);
     let original: serde_json::Value = serde_json::from_slice(old_json).unwrap();
     let mut retained = serde_json::to_value(&from_json).unwrap();
-    assert_eq!(retained["schema_version"], 5);
+    assert_eq!(retained["schema_version"], 3);
     retained["schema_version"] = 2.into();
-    let allocations: Vec<_> = from_json
-        .relations
-        .values()
-        .filter_map(|relation| {
-            if let RelationBody::InterfaceItemAllocation {
-                source,
-                target,
-                order,
-                ..
-            } = relation.body
-            {
-                Some((source, target, order))
-            } else {
-                None
-            }
-        })
-        .collect();
     for element in retained["elements"].as_object_mut().unwrap().values_mut() {
-        let element_id: Id = element["id"].as_str().unwrap().parse().unwrap();
         for layer in ["Oa", "Sa"] {
             let Some(shared) = element["body"]
                 .get_mut(layer)
@@ -827,46 +779,6 @@ fn original_v2_text_and_json_preserve_identity_and_mixed_scenarios_after_extensi
                 assert_eq!(port["contract"], "Legacy");
                 *port = port["legacy"].clone();
             }
-            if let Some(item) = shared
-                .get_mut("ExchangeItem")
-                .and_then(serde_json::Value::as_object_mut)
-            {
-                if item["mechanism"] == "Event" {
-                    item.insert("kind".into(), "Event".into());
-                }
-                item.remove("mechanism");
-                item.remove("supertype");
-            }
-            if let Some(kind) = shared
-                .get_mut("DataType")
-                .and_then(serde_json::Value::as_object_mut)
-            {
-                kind.remove("default");
-                kind.remove("unit");
-                let definition = &kind["definition"];
-                if let Some(name) = ["Integer", "Real", "String", "Record"]
-                    .into_iter()
-                    .find(|name| definition.get(name).is_some())
-                {
-                    kind.insert("definition".into(), name.into());
-                }
-            }
-            if let Some(field) = shared
-                .get_mut("DataField")
-                .and_then(serde_json::Value::as_object_mut)
-            {
-                for key in ["direction", "storage", "default"] {
-                    field.remove(key);
-                }
-            }
-            if let Some(interface) = shared.get_mut("Interface") {
-                let mut entries: Vec<_> = allocations
-                    .iter()
-                    .filter(|(source, _, _)| *source == element_id)
-                    .collect();
-                entries.sort_by_key(|(_, _, order)| *order);
-                *interface = serde_json::json!({"items":entries.into_iter().map(|(_,target,_)|target).collect::<Vec<_>>()});
-            }
             if let Some(scenario) = shared
                 .get_mut("Scenario")
                 .and_then(serde_json::Value::as_object_mut)
@@ -885,10 +797,6 @@ fn original_v2_text_and_json_preserve_identity_and_mixed_scenarios_after_extensi
             }
         }
     }
-    retained["relations"]
-        .as_object_mut()
-        .unwrap()
-        .retain(|_, relation| relation["body"].get("InterfaceItemAllocation").is_none());
     for relation in retained["relations"].as_object_mut().unwrap().values_mut() {
         if let Some(boundary) = relation["body"].get_mut("BoundaryExchange") {
             assert_eq!(boundary["oriented"], true);
@@ -918,7 +826,7 @@ fn original_v2_text_and_json_preserve_identity_and_mixed_scenarios_after_extensi
     );
     assert_eq!(
         from_json.relations.len(),
-        original["relations"].as_object().unwrap().len() + allocations.len()
+        original["relations"].as_object().unwrap().len()
     );
     assert_eq!(
         from_json.diagrams.len(),
@@ -991,7 +899,7 @@ fn v1_text_and_json_migrate_deterministically_without_losing_legacy_semantics()
     assert_eq!(from_text, from_json);
     assert_eq!(read(text), from_text);
     assert_eq!(persistence::decode(json).unwrap(), from_json);
-    assert_eq!(from_text.schema_version, 5);
+    assert_eq!(from_text.schema_version, 3);
     assert!(!from_text.elements.values().any(|e| e.layer() == Layer::Sa));
     let raw: serde_json::Value = serde_json::from_slice(json).unwrap();
     for (id, record) in raw["elements"].as_object().unwrap() {
@@ -1192,8 +1100,6 @@ fn complete_normative_examples_are_accepted_by_the_real_parser() {
         }
         if code.trim_start().starts_with("arcadia 2;")
             || code.trim_start().starts_with("arcadia 3;")
-            || code.trim_start().starts_with("arcadia 4;")
-            || code.trim_start().starts_with("arcadia 5;")
         {
             read(&code);
             examples += 1;

crates/oa-core/tests/port_migration.rs

@@ -39,7 +39,7 @@ fn frozen_original_v2_reader_preserves_every_original_record() {
     assert_eq!(decoded.project, from_source.project);
     assert_eq!(decoded.migration, from_source.migration);
     let report = decoded.migration.unwrap();
-    assert_eq!((report.from_schema, report.to_schema), (2, 5));
+    assert_eq!((report.from_schema, report.to_schema), (2, 3));
     assert_eq!(report.preserved_ports.len(), 4);
     assert!(report.generated_endpoints.is_empty());
     assert_eq!(report.orientation_defaults.len(), 1);
@@ -56,7 +56,6 @@ fn frozen_original_v2_reader_preserves_every_original_record() {
             + old["traces"].as_object().unwrap().len()
             + old["artifact_links"].as_object().unwrap().len()
             + 1
-            + report.generated_interface_allocations.len()
     );
     let mut current = serde_json::to_value(&decoded.project).unwrap();
     for diagram in current["diagrams"].as_object_mut().unwrap().values_mut() {
@@ -144,7 +143,7 @@ fn missing_v2_endpoints_are_deterministic_reported_and_independently_typed() {
         }
     }
     let canonical = language::format(&first.project);
-    assert!(canonical.starts_with("arcadia 5;"));
+    assert!(canonical.starts_with("arcadia 3;"));
     let reopened = persistence::decode_with_report(canonical.as_bytes()).unwrap();
     assert!(reopened.migration.is_none());
     assert_eq!(reopened.project, first.project);
@@ -224,13 +223,7 @@ fn migration_admission_counts_generated_objects_records_and_references() {
                         _ => 0,
                     })
             })
-            .sum::<usize>()
-        + decode(&old)
-            .migration
-            .unwrap()
-            .generated_interface_allocations
-            .len()
-            * 2;
+            .sum::<usize>();
     for limits in [
         ParseLimits {
             max_graph_objects: graph + 1,
@@ -251,7 +244,7 @@ fn migration_admission_counts_generated_objects_records_and_references() {
         ));
     }
     let accepted = ParseLimits {
-        max_graph_objects: migrated.elements.len() + migrated.relations.len(),
+        max_graph_objects: graph + 2,
         max_records: records,
         max_step_references: reference_count,
         ..ParseLimits::UNLIMITED
@@ -274,7 +267,7 @@ fn old_contract_is_validated_before_new_shapes_and_v1_flows_through_v2() {
     assert!(error.contains("V2") && error.contains(&fe), "{error}");
     let v1 = include_bytes!("../../../examples/legacy-v1-coastal-rescue.oa.json");
     let result = persistence::decode_with_report(v1).unwrap();
-    assert_eq!(result.project.schema_version, 5);
+    assert_eq!(result.project.schema_version, 3);
     assert_eq!(result.migration.unwrap().from_schema, 1);
     assert_eq!(persistence::decode(v1).unwrap(), result.project);
 }

crates/oa-core/tests/port_source.rs

@@ -1,6 +1,6 @@
 use oa_core::{language, persistence, *};
 
-const SOURCE: &str = r#"arcadia 4;
+const SOURCE: &str = r#"arcadia 3;
 project typed_ports "Typed ports" {
     sa_system producer "Producer" {}
     sa_actor consumer "Consumer" {}
@@ -9,8 +9,7 @@ project typed_ports "Typed ports" {
     allocation sends "Produces" { source @producer; target @send; }
     allocation receives "Consumes" { source @consumer; target @receive; }
     sa_exchange_item data "Data" {}
-    sa_interface service "Service" {}
-    interface_item_allocation service_data "Service data" { source @service; target @data; }
+    sa_interface service "Service" { items [@data]; }
     sa_port output "Output" { parent @send; contract { FunctionOutput { outgoing_items [@data]; }; }; }
     sa_port input "Input" { parent @receive; contract { FunctionInput { incoming_items [@data]; }; }; }
     sa_port provider "Provider port" { parent @producer; contract { Component { kind Standard; orientation Unset; }; }; }
@@ -27,10 +26,9 @@ project typed_ports "Typed ports" {
 "#;
 
 #[test]
-fn source4_covers_typed_contracts_roles_allocations_and_nested_legacy_references() {
+fn source3_covers_typed_contracts_roles_allocations_and_nested_legacy_references() {
     let decoded = language::parse_with_report(SOURCE).unwrap();
-    let migration = decoded.migration.as_ref().unwrap();
-    assert_eq!((migration.from_schema, migration.to_schema), (4, 5));
+    assert!(decoded.migration.is_none());
     let canonical = language::format(&decoded.project);
     for field in [
         "incoming_items [@data]",
@@ -71,7 +69,7 @@ fn source4_covers_typed_contracts_roles_allocations_and_nested_legacy_references
 }
 
 #[test]
-fn source4_requires_explicit_port_contract_and_fe_endpoints_without_generation() {
+fn source3_requires_explicit_port_contract_and_fe_endpoints_without_generation() {
     for (remove, expected) in [
         ("source_port @output; ", "source_port"),
         ("target_port @input; ", "target_port"),
@@ -92,7 +90,7 @@ fn source4_requires_explicit_port_contract_and_fe_endpoints_without_generation()
 }
 
 #[test]
-fn source4_rejects_mixed_component_kinds_and_nested_reference_typos() {
+fn source3_rejects_mixed_component_kinds_and_nested_reference_typos() {
     let mixed = SOURCE.replace(
         "parent @consumer; contract { Component { kind Standard; orientation Unset;",
         "parent @consumer; contract { Component { kind Flow; orientation Unset;",

crates/oa-core/tests/r3_constructor_ack.rs

@@ -1,680 +0,0 @@
-use oa_core::{transitions::*, *};
-use std::collections::BTreeMap;
-
-#[derive(Clone, Copy, Debug)]
-enum Family {
-    Data,
-    Port,
-    Occurrence,
-    Message,
-    Event,
-    State,
-}
-const FAMILIES: [Family; 6] = [
-    Family::Data,
-    Family::Port,
-    Family::Occurrence,
-    Family::Message,
-    Family::Event,
-    Family::State,
-];
-
-fn add(p: &mut Project, kind: Kind, layer: Layer, parent: Option<Id>) -> Id {
-    p.add_element(kind, layer, "reviewed", parent).unwrap()
-}
-fn trace(p: &mut Project, oa: Id, sa: Id) -> Id {
-    let id = Id::new_v4();
-    p.traces.insert(
-        id,
-        Trace {
-            id,
-            alias: format!("review_{}", id.simple()),
-            name: "Review".into(),
-            description: String::new(),
-            oa,
-            sa,
-            kind: TraceKind::Manual,
-            baseline: Some(TraceBaseline {
-                oa: p.properties(oa).unwrap(),
-                sa: p.properties(sa).unwrap(),
-                semantic: None,
-            }),
-        },
-    );
-    id
-}
-fn set(p: &mut Project, id: Id, body: SharedBody) {
-    *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = body;
-}
-fn integer(p: &mut Project, id: Id) {
-    set(
-        p,
-        id,
-        SharedBody::DataType {
-            definition: DataTypeDefinition::Integer {
-                minimum: Some(0),
-                maximum: Some(10),
-            },
-            default: None,
-            unit: "m".into(),
-        },
-    );
-}
-fn fixture(family: Family) -> (Project, Id, Id, Id, FacetSelector, FacetSelector) {
-    let mut p = Project::empty();
-    let mut pair = vec![];
-    for layer in [Layer::Oa, Layer::Sa] {
-        let id = match family {
-            Family::Data => {
-                let id = add(&mut p, Kind::DataType, layer, None);
-                integer(&mut p, id);
-                id
-            }
-            Family::Port => {
-                let kind = if layer == Layer::Oa {
-                    Kind::Actor
-                } else {
-                    Kind::SystemActor
-                };
-                let owner = add(&mut p, kind, layer, None);
-                let id = Id::new_v4();
-                let mut port = make_port(&p, id, owner, "port", PortContract::Legacy).unwrap();
-                if let Some(SharedBody::Port { legacy, .. }) = port.shared_mut() {
-                    *legacy = Some(LegacyPortContract {
-                        direction: PortDirection::InOut,
-                        interface: None,
-                    });
-                }
-                p.elements.insert(id, port);
-                id
-            }
-            Family::Occurrence | Family::Message => {
-                let owner = add(&mut p, Kind::Scenario, layer, None);
-                let id = add(&mut p, Kind::Occurrence, layer, Some(owner));
-                p.elements
-                    .get_mut(&owner)
-                    .unwrap()
-                    .steps_mut()
-                    .unwrap()
-                    .push(id);
-                set(
-                    &mut p,
-                    id,
-                    SharedBody::Occurrence {
-                        body: OccurrenceBody::Exchange {
-                            exchange: None,
-                            sender: None,
-                            receiver: None,
-                            message_kind: MessageKind::Timer {
-                                expression: "10s".into(),
-                            },
-                            reply_to: None,
-                            values: vec![],
-                        },
-                        precondition: String::new(),
-                        postcondition: String::new(),
-                    },
-                );
-                id
-            }
-            Family::Event => {
-                let id = add(&mut p, Kind::Event, layer, None);
-                set(
-                    &mut p,
-                    id,
-                    SharedBody::Event {
-                        body: EventBody::Time {
-                            kind: TimeEventKind::After,
-                            expression: "10s".into(),
-                        },
-                    },
-                );
-                id
-            }
-            Family::State => {
-                let machine = add(&mut p, Kind::StateMachine, layer, None);
-                let region = add(&mut p, Kind::Region, layer, Some(machine));
-                add(&mut p, Kind::State, layer, Some(region))
-            }
-        };
-        pair.push(id);
-    }
-    let (oa, sa) = (pair[0], pair[1]);
-    let t = trace(&mut p, oa, sa);
-    let (constructor, descendant) = match family {
-        Family::Data => (
-            FacetSelector::Data(DataFacet::Constructor),
-            FacetSelector::Data(DataFacet::IntegerMaximum),
-        ),
-        Family::Port => (
-            FacetSelector::Port(PortFacet::Constructor),
-            FacetSelector::Port(PortFacet::LegacyDirection),
-        ),
-        Family::Occurrence => (
-            FacetSelector::Occurrence(OccurrenceFacet::Constructor),
-            FacetSelector::Occurrence(OccurrenceFacet::TimerExpression),
-        ),
-        Family::Message => (
-            FacetSelector::Occurrence(OccurrenceFacet::MessageKind),
-            FacetSelector::Occurrence(OccurrenceFacet::TimerExpression),
-        ),
-        Family::Event => (
-            FacetSelector::Event(EventFacet::Constructor),
-            FacetSelector::Event(EventFacet::TimeExpression),
-        ),
-        Family::State => (
-            FacetSelector::State(StateFacet::Kind),
-            FacetSelector::State(StateFacet::Entry),
-        ),
-    };
-    (p, oa, sa, t, constructor, descendant)
-}
-fn change_descendant(p: &mut Project, id: Id) {
-    match p.elements.get_mut(&id).unwrap().shared_mut().unwrap() {
-        SharedBody::DataType {
-            definition: DataTypeDefinition::Integer { maximum, .. },
-            ..
-        } => *maximum = Some(20),
-        SharedBody::Port {
-            legacy: Some(LegacyPortContract { direction, .. }),
-            ..
-        } => *direction = PortDirection::Out,
-        SharedBody::Occurrence {
-            body:
-                OccurrenceBody::Exchange {
-                    message_kind: MessageKind::Timer { expression },
-                    ..
-                },
-            ..
-        }
-        | SharedBody::Event {
-            body: EventBody::Time { expression, .. },
-        } => *expression = "20s".into(),
-        SharedBody::State { entry, .. } => *entry = "initialize".into(),
-        _ => panic!("Unexpected test family"),
-    }
-}
-fn request(
-    oa: Id,
-    sa: Id,
-    reverse: bool,
-    resolutions: Vec<(FacetSelector, SemanticDecision)>,
-) -> SemanticTransitionRequest {
-    let (direction, source, target) = if reverse {
-        (TransitionDirection::SaToOa, sa, oa)
-    } else {
-        (TransitionDirection::OaToSa, oa, sa)
-    };
-    let mut transition = TransitionRequest::new(direction, vec![source]);
-    transition.mappings.push(TransitionMapping {
-        source,
-        target: Some(target),
-        target_kind: None,
-    });
-    let mut r = SemanticTransitionRequest::new(transition);
-    r.reviews.push(SemanticReviewRequest {
-        source,
-        resolutions: resolutions
-            .into_iter()
-            .map(|(facet, decision)| FacetResolution { facet, decision })
-            .collect(),
-        reset: vec![],
-    });
-    r
-}
-fn apply(p: &Project, r: SemanticTransitionRequest) -> (Project, SemanticTransitionPlan) {
-    let plan = plan_semantic_transition(p, r).unwrap();
-    assert!(plan.conflicts.is_empty(), "{:?}", plan.conflicts);
-    (apply_semantic_transition(p, &plan).unwrap(), plan)
-}
-fn drift(p: &Project, t: Id, selector: &FacetSelector) -> Drift {
-    semantic_facets(p, &p.traces[&t], &BTreeMap::new())
-        .unwrap()
-        .into_iter()
-        .find(|f| f.selector == *selector)
-        .unwrap()
-        .drift
-}
-
-#[test]
-fn first_equal_constructor_acknowledges_only_discriminator_in_every_family_and_direction() {
-    for family in FAMILIES {
-        for reverse in [false, true] {
-            for decision in [
-                SemanticDecision::KeepTarget,
-                SemanticDecision::TakeSource,
-                SemanticDecision::Candidate,
-            ] {
-                let (mut p, oa, sa, t, constructor, descendant) = fixture(family);
-                let (source, target) = if reverse { (sa, oa) } else { (oa, sa) };
-                change_descendant(&mut p, target);
-                let mut r = request(oa, sa, reverse, vec![(constructor.clone(), decision)]);
-                if decision == SemanticDecision::Candidate {
-                    r.candidates
-                        .push(SemanticRecord::Element(p.elements[&target].clone()));
-                }
-                let (q, plan) = apply(&p, r.clone());
-                assert_eq!(q.elements, p.elements, "{family:?} {decision:?}");
-                assert_eq!(plan.reviews[0].acknowledged, vec![constructor.clone()]);
-                assert!(plan.reviews[0].retired.is_empty());
-                let facts = semantic_facets(&q, &q.traces[&t], &BTreeMap::new()).unwrap();
-                assert!(facts.iter().all(|f| f.drift
-                    == if f.selector == constructor {
-                        Drift::Unchanged
-                    } else {
-                        Drift::Unreviewed
-                    }));
-                let (mut q, _) = apply(
-                    &q,
-                    request(
-                        oa,
-                        sa,
-                        reverse,
-                        vec![(descendant.clone(), SemanticDecision::KeepTarget)],
-                    ),
-                );
-                change_descendant(&mut q, source);
-                assert_eq!(
-                    drift(&q, t, &descendant),
-                    if reverse {
-                        Drift::SaChanged
-                    } else {
-                        Drift::OaChanged
-                    }
-                );
-                let repeated = plan_semantic_transition(&q, r).unwrap();
-                assert!(
-                    repeated
-                        .conflicts
-                        .iter()
-                        .any(|c| c.contains("No constructor switch"))
-                );
-                assert!(apply_semantic_transition(&q, &repeated).is_err());
-            }
-        }
-    }
-}
-
-#[test]
-fn independent_constructor_and_leaf_selections_complete_missing_or_empty_baselines() {
-    for family in FAMILIES {
-        for reverse in [false, true] {
-            for history in 0..3 {
-                let (mut p, oa, sa, t, _, _) = fixture(family);
-                if history == 0 {
-                    p.traces.get_mut(&t).unwrap().baseline = None;
-                } else if history == 2 {
-                    p.traces
-                        .get_mut(&t)
-                        .unwrap()
-                        .baseline
-                        .as_mut()
-                        .unwrap()
-                        .semantic = Some(SemanticBaseline::default());
-                }
-                let selectors: Vec<_> = semantic_facets(&p, &p.traces[&t], &BTreeMap::new())
-                    .unwrap()
-                    .into_iter()
-                    .map(|f| f.selector)
-                    .collect();
-                let (q, plan) = apply(
-                    &p,
-                    request(
-                        oa,
-                        sa,
-                        reverse,
-                        selectors
-                            .iter()
-                            .cloned()
-                            .map(|s| (s, SemanticDecision::KeepTarget))
-                            .collect(),
-                    ),
-                );
-                assert_eq!(q.elements, p.elements);
-                assert_eq!(plan.reviews[0].acknowledged.len(), selectors.len());
-                assert!(plan.reviews[0].retired.is_empty());
-                let status = trace_semantic_drift(&q, &q.traces[&t], &BTreeMap::new()).unwrap();
-                assert_eq!(status.own, Drift::Unchanged, "{family:?} {history}");
-                assert!(!status.own_unreviewed);
-            }
-        }
-    }
-}
-
-#[test]
-fn migrated_equal_constructor_can_complete_semantic_review_without_model_changes() {
-    let json = include_str!("fixtures/v4-reviewed-prose.json")
-        .replace("\"Real\"", "\"Integer\"")
-        .replace("0.0", "0")
-        .replace("100.0", "100")
-        .replace("20.0", "20");
-    for reverse in [false, true] {
-        let decoded = persistence::decode_with_report(json.as_bytes()).unwrap();
-        let report = decoded.migration.unwrap();
-        assert_eq!((report.from_schema, report.to_schema), (4, 5));
-        let p = decoded.project;
-        let t = p.traces.values().next().unwrap();
-        assert!(t.baseline.as_ref().unwrap().semantic.is_none());
-        let original_prose = t.baseline.clone().unwrap();
-        let (oa, sa, id) = (t.oa, t.sa, t.id);
-        let selections = semantic_facets(&p, t, &BTreeMap::new())
-            .unwrap()
-            .into_iter()
-            .map(|f| (f.selector, SemanticDecision::KeepTarget))
-            .collect();
-        let (q, _) = apply(&p, request(oa, sa, reverse, selections));
-        assert_eq!(q.elements, p.elements);
-        let baseline = q.traces[&id].baseline.as_ref().unwrap();
-        assert_eq!(baseline.oa, original_prose.oa);
-        assert_eq!(baseline.sa, original_prose.sa);
-        let status = trace_semantic_drift(&q, &q.traces[&id], &BTreeMap::new()).unwrap();
-        assert_eq!(status.own, Drift::Unchanged);
-        assert!(!status.own_unreviewed);
-    }
-}
-
-#[test]
-fn equal_constructor_candidate_requires_independent_selection_of_changed_descendants() {
-    for reverse in [false, true] {
-        let (p, oa, sa, t, constructor, descendant) = fixture(Family::Data);
-        let target = if reverse { oa } else { sa };
-        let mut changed = p.clone();
-        change_descendant(&mut changed, target);
-        let mut r = request(
-            oa,
-            sa,
-            reverse,
-            vec![(constructor.clone(), SemanticDecision::Candidate)],
-        );
-        r.candidates
-            .push(SemanticRecord::Element(changed.elements[&target].clone()));
-        let invalid = plan_semantic_transition(&p, r.clone()).unwrap();
-        assert!(
-            invalid
-                .conflicts
-                .iter()
-                .any(|c| c.contains("changes an unselected facet"))
-        );
-        assert!(apply_semantic_transition(&p, &invalid).is_err());
-        r.reviews[0].resolutions.push(FacetResolution {
-            facet: descendant.clone(),
-            decision: SemanticDecision::Candidate,
-        });
-        let (q, plan) = apply(&p, r);
-        assert_eq!(q.elements, changed.elements);
-        assert_eq!(plan.reviews[0].acknowledged.len(), 2);
-        assert_eq!(drift(&q, t, &constructor), Drift::Unchanged);
-        assert_eq!(drift(&q, t, &descendant), Drift::Unchanged);
-        assert_eq!(
-            drift(&q, t, &FacetSelector::Data(DataFacet::Default)),
-            Drift::Unreviewed
-        );
-    }
-}
-
-#[test]
-fn reset_equal_constructor_does_not_refresh_previously_reviewed_descendants() {
-    for reverse in [false, true] {
-        let (p, oa, sa, t, constructor, descendant) = fixture(Family::Data);
-        let (mut p, _) = apply(
-            &p,
-            request(
-                oa,
-                sa,
-                reverse,
-                vec![
-                    (constructor.clone(), SemanticDecision::KeepTarget),
-                    (descendant.clone(), SemanticDecision::KeepTarget),
-                ],
-            ),
-        );
-        let original = p.traces[&t]
-            .baseline
-            .as_ref()
-            .unwrap()
-            .semantic
-            .as_ref()
-            .unwrap()
-            .clone();
-        change_descendant(&mut p, if reverse { sa } else { oa });
-        let mut r = request(
-            oa,
-            sa,
-            reverse,
-            vec![(constructor.clone(), SemanticDecision::KeepTarget)],
-        );
-        r.reviews[0].reset.push(constructor.clone());
-        let (q, plan) = apply(&p, r);
-        assert_eq!(q.elements, p.elements);
-        assert_eq!(plan.reviews[0].acknowledged, vec![constructor]);
-        assert!(plan.reviews[0].retired.is_empty());
-        assert_eq!(
-            q.traces[&t]
-                .baseline
-                .as_ref()
-                .unwrap()
-                .semantic
-                .as_ref()
-                .unwrap(),
-            &original
-        );
-        assert_eq!(
-            drift(&q, t, &descendant),
-            if reverse {
-                Drift::SaChanged
-            } else {
-                Drift::OaChanged
-            }
-        );
-    }
-}
-
-#[test]
-fn first_constructor_acknowledgement_agrees_only_on_its_canonical_discriminator_slot() {
-    for switch in [false, true] {
-        let (mut p, oa, sa, t, constructor, descendant) = fixture(Family::Data);
-        let second = add(&mut p, Kind::DataType, Layer::Oa, None);
-        integer(&mut p, second);
-        if switch {
-            set(
-                &mut p,
-                second,
-                SharedBody::DataType {
-                    definition: DataTypeDefinition::Real {
-                        minimum: Some(0.),
-                        maximum: Some(30.),
-                    },
-                    default: None,
-                    unit: "m".into(),
-                },
-            );
-        } else {
-            change_descendant(&mut p, second);
-        }
-        trace(&mut p, second, sa);
-        let mut r = request(
-            oa,
-            sa,
-            false,
-            vec![(constructor.clone(), SemanticDecision::KeepTarget)],
-        );
-        r.transition.sources.push(second);
-        r.transition.mappings.push(TransitionMapping {
-            source: second,
-            target: Some(sa),
-            target_kind: None,
-        });
-        r.reviews.push(SemanticReviewRequest {
-            source: second,
-            reset: vec![],
-            resolutions: vec![FacetResolution {
-                facet: if switch {
-                    constructor.clone()
-                } else {
-                    descendant.clone()
-                },
-                decision: SemanticDecision::TakeSource,
-            }],
-        });
-        for reversed in [false, true] {
-            let mut r = r.clone();
-            if reversed {
-                r.reviews.reverse();
-            }
-            let plan = plan_semantic_transition(&p, r).unwrap();
-            if switch {
-                assert!(plan.conflicts.iter().any(|c| c.contains("Contradictory")));
-                assert!(apply_semantic_transition(&p, &plan).is_err());
-            } else {
-                assert!(plan.conflicts.is_empty(), "{:?}", plan.conflicts);
-                let q = apply_semantic_transition(&p, &plan).unwrap();
-                assert_eq!(drift(&q, t, &constructor), Drift::Unchanged);
-                assert_eq!(drift(&q, t, &descendant), Drift::Unreviewed);
-                assert!(matches!(
-                    q.elements[&sa].shared(),
-                    Some(SharedBody::DataType {
-                        definition: DataTypeDefinition::Integer {
-                            maximum: Some(20),
-                            ..
-                        },
-                        ..
-                    })
-                ));
-            }
-        }
-    }
-}
-
-#[test]
-fn one_sided_or_disappeared_message_constructor_is_not_an_equal_scalar_acknowledgement() {
-    for reverse in [false, true] {
-        let (mut p, oa, sa, t, constructor, descendant) = fixture(Family::Message);
-        let source = if reverse { sa } else { oa };
-        let target = if reverse { oa } else { sa };
-        let mut action = p.elements[&source].shared().unwrap().clone();
-        if let SharedBody::Occurrence { body, .. } = &mut action {
-            *body = OccurrenceBody::Action {
-                action: None,
-                lifeline: None,
-            };
-        }
-        set(&mut p, source, action.clone());
-        let (q, plan) = apply(
-            &p,
-            request(
-                oa,
-                sa,
-                reverse,
-                vec![(constructor.clone(), SemanticDecision::KeepTarget)],
-            ),
-        );
-        // One-sided applicability still has a constructor-group scope and records its timer leaf.
-        assert_eq!(
-            plan.reviews[0].acknowledged,
-            vec![constructor.clone(), descendant.clone()]
-        );
-        assert_eq!(q.elements, p.elements);
-        assert_eq!(drift(&q, t, &descendant), Drift::Unchanged);
-        let mut p = q;
-        set(&mut p, target, action);
-        let mut r = request(
-            oa,
-            sa,
-            reverse,
-            vec![(constructor.clone(), SemanticDecision::KeepTarget)],
-        );
-        r.reviews[0].reset.push(constructor);
-        let plan = plan_semantic_transition(&p, r).unwrap();
-        assert!(!plan.conflicts.is_empty());
-        assert!(apply_semantic_transition(&p, &plan).is_err());
-    }
-}
-
-#[test]
-fn historical_switches_retain_groups_and_completed_requests_still_reject_in_both_directions() {
-    for reverse in [false, true] {
-        let (p, oa, sa, t, constructor, _) = fixture(Family::Data);
-        let (source, target) = if reverse { (sa, oa) } else { (oa, sa) };
-        let keep = request(
-            oa,
-            sa,
-            reverse,
-            vec![(constructor.clone(), SemanticDecision::KeepTarget)],
-        );
-        let (mut p, _) = apply(&p, keep.clone());
-        set(
-            &mut p,
-            source,
-            SharedBody::DataType {
-                definition: DataTypeDefinition::Real {
-                    minimum: Some(0.),
-                    maximum: Some(20.),
-                },
-                default: None,
-                unit: "m".into(),
-            },
-        );
-        let (mut q, plan) = apply(&p, keep.clone());
-        let maximum = FacetSelector::Data(DataFacet::RealMaximum);
-        assert!(plan.reviews[0].acknowledged.contains(&maximum));
-        assert!(
-            plan.reviews[0]
-                .acknowledged
-                .contains(&FacetSelector::Data(DataFacet::Default))
-        );
-        assert!(
-            !plan.reviews[0]
-                .acknowledged
-                .contains(&FacetSelector::Data(DataFacet::Unit))
-        );
-        assert_eq!(q.elements, p.elements);
-        if let Some(SharedBody::DataType {
-            definition: DataTypeDefinition::Real { maximum, .. },
-            ..
-        }) = q.elements.get_mut(&source).unwrap().shared_mut()
-        {
-            *maximum = Some(30.);
-        }
-        let repeated = plan_semantic_transition(&q, keep).unwrap();
-        assert!(
-            repeated
-                .conflicts
-                .iter()
-                .any(|c| c.contains("No constructor switch"))
-        );
-        assert!(apply_semantic_transition(&q, &repeated).is_err());
-        assert_eq!(
-            drift(&q, t, &maximum),
-            if reverse {
-                Drift::SaChanged
-            } else {
-                Drift::OaChanged
-            }
-        );
-        let take = request(
-            oa,
-            sa,
-            reverse,
-            vec![(constructor, SemanticDecision::TakeSource)],
-        );
-        let (p, _) = apply(&q, take.clone());
-        assert!(matches!(
-            p.elements[&target].shared(),
-            Some(SharedBody::DataType {
-                definition: DataTypeDefinition::Real {
-                    maximum: Some(30.),
-                    ..
-                },
-                ..
-            })
-        ));
-        let completed = plan_semantic_transition(&p, take).unwrap();
-        assert!(
-            completed
-                .conflicts
-                .iter()
-                .any(|c| c.contains("No constructor switch"))
-        );
-        assert!(apply_semantic_transition(&p, &completed).is_err());
-    }
-}

crates/oa-core/tests/r3_migration.rs

@@ -1,169 +0,0 @@
-use oa_core::{language, persistence, source_project::*, *};
-use serde_json::Value;
-use std::collections::BTreeMap;
-
-const JSON4: &[u8] = include_bytes!("fixtures/v4-reviewed-prose.json");
-const SOURCE4: &str = include_str!("fixtures/v4-reviewed-prose.arcadia");
-
-#[test]
-fn frozen_v4_json_and_source_preserve_the_old_review_without_fabricating_semantics() {
-    let json = persistence::decode_with_report(JSON4).unwrap();
-    let source = language::parse_with_report(SOURCE4).unwrap();
-    assert_eq!(json.project, source.project);
-    for decoded in [json, source] {
-        assert_eq!(decoded.project.schema_version, 5);
-        let report = decoded.migration.unwrap();
-        assert_eq!((report.from_schema, report.to_schema), (4, 5));
-        let trace = decoded.project.traces.values().next().unwrap();
-        let baseline = trace.baseline.as_ref().unwrap();
-        assert!(baseline.semantic.is_none());
-        assert_eq!(baseline.oa.name, "Approved OA name");
-        assert_eq!(baseline.oa.description, "Approved OA\nprose");
-        assert_eq!(baseline.sa.name, "Approved SA name");
-        assert_ne!(baseline.oa.name, decoded.project.named(trace.oa));
-        let mut expected: Value = serde_json::from_slice(JSON4).unwrap();
-        expected["schema_version"] = 5.into();
-        assert_eq!(serde_json::to_value(&decoded.project).unwrap(), expected);
-        let reopened =
-            persistence::decode_with_report(&serde_json::to_vec(&decoded.project).unwrap())
-                .unwrap();
-        assert!(reopened.migration.is_none());
-        assert_eq!(reopened.project, decoded.project);
-    }
-}
-
-#[test]
-fn older_headers_cannot_admit_new_semantic_baselines() {
-    let mut value: Value = serde_json::from_slice(JSON4).unwrap();
-    let trace = value["traces"]
-        .as_object_mut()
-        .unwrap()
-        .values_mut()
-        .next()
-        .unwrap();
-    trace["baseline"]["semantic"] = serde_json::json!({"facets": []});
-    for version in [3, 4] {
-        value["schema_version"] = version.into();
-        let error = persistence::decode(&serde_json::to_vec(&value).unwrap())
-            .unwrap_err()
-            .to_string();
-        assert!(error.contains("semantic"), "{error}");
-    }
-    let source = SOURCE4.replace("baseline {", "baseline { semantic { facets []; };");
-    assert!(
-        language::parse(&source)
-            .unwrap_err()
-            .iter()
-            .any(|d| d.message.contains("require schema/source5"))
-    );
-    let bundle = SourceBundle {
-        entry: "project.arcadia".into(),
-        files: BTreeMap::from([("project.arcadia".into(), source)]),
-    };
-    assert!(
-        compile_bundle(&bundle, ProjectLimits::default())
-            .unwrap_err()
-            .iter()
-            .any(|d| d.diagnostic.message.contains("require schema/source5"))
-    );
-}
-
-#[test]
-fn frozen_v4_trace_envelope_keeps_duplicate_and_unknown_field_rejection() {
-    let json = std::str::from_utf8(JSON4).unwrap();
-    let duplicate = json.replace("\"baseline\": {", "\"baseline\": null, \"baseline\": {");
-    assert!(
-        persistence::decode(duplicate.as_bytes())
-            .unwrap_err()
-            .to_string()
-            .contains("duplicate field")
-    );
-    let unknown = json.replace("\"baseline\": {", "\"baseline\": { \"reviewed\": true,");
-    assert!(
-        persistence::decode(unknown.as_bytes())
-            .unwrap_err()
-            .to_string()
-            .contains("unknown field")
-    );
-}
-
-#[test]
-fn authored_v4_modules_upgrade_only_the_version_and_preserve_nested_comments() {
-    let start = SOURCE4.find("    oa_data_type").unwrap();
-    let end = SOURCE4.rfind('}').unwrap();
-    let entry = format!(
-        "{}    include \"contracts.arcadia\";\n}}\n",
-        &SOURCE4[..start]
-    );
-    let mut module =
-        SOURCE4[start..end].replace("baseline {", "baseline { // original review rationale");
-    module.push_str(
-        r#"
-    oa_data_type record "Independent record" id "40000000-0000-4000-8000-000000000011" {
-        definition { Record { supertype none; }; };
-        // This field remains inside its authored record.
-        oa_data_field flag "Flag" id "40000000-0000-4000-8000-000000000012" { type_ref Boolean; }
-    }
-"#,
-    );
-    let bundle = SourceBundle {
-        entry: "project.arcadia".into(),
-        files: BTreeMap::from([
-            ("project.arcadia".into(), entry.clone()),
-            ("contracts.arcadia".into(), module.clone()),
-        ]),
-    };
-    let compiled = compile_bundle(&bundle, ProjectLimits::default()).unwrap();
-    assert_eq!(compiled.bundle.files["contracts.arcadia"], module);
-    assert_eq!(
-        compiled.bundle.files["project.arcadia"],
-        entry.replacen("arcadia 4;", "arcadia 5;", 1)
-    );
-    assert_eq!(
-        compiled.index.lexical_owners
-            [&Id::parse_str("40000000-0000-4000-8000-000000000012").unwrap()],
-        Id::parse_str("40000000-0000-4000-8000-000000000011").unwrap()
-    );
-    let reopened = compile_bundle(&compiled.bundle, ProjectLimits::default()).unwrap();
-    assert!(reopened.decoded.migration.is_none());
-    assert_eq!(reopened.bundle, compiled.bundle);
-    assert_eq!(reopened.decoded.project, compiled.decoded.project);
-    assert_eq!(
-        bundle.files["project.arcadia"], entry,
-        "caller draft is unchanged"
-    );
-}
-
-#[test]
-fn original_v1_v2_v3_inputs_complete_the_explicit_upgrade_to_five() {
-    for (version, bytes) in [
-        (
-            1,
-            include_bytes!("../../../examples/legacy-v1-coastal-rescue.oa.json").as_slice(),
-        ),
-        (
-            2,
-            include_bytes!("fixtures/v2-coastal-rescue.json").as_slice(),
-        ),
-        (
-            3,
-            include_bytes!("fixtures/v3-data-contract.json").as_slice(),
-        ),
-    ] {
-        let decoded = persistence::decode_with_report(bytes).unwrap();
-        let report = decoded.migration.unwrap();
-        assert_eq!((report.from_schema, report.to_schema), (version, 5));
-        assert_eq!(decoded.project.schema_version, 5);
-        assert!(
-            decoded
-                .project
-                .traces
-                .values()
-                .all(|t| t.baseline.as_ref().is_none_or(|b| b.semantic.is_none()))
-        );
-        assert_eq!(
-            language::parse(&language::format(&decoded.project)).unwrap(),
-            decoded.project
-        );
-    }
-}

crates/oa-core/tests/r3_source.rs

@@ -1,431 +0,0 @@
-use oa_core::{language, persistence, semantic::*, source_project::*, *};
-use std::collections::BTreeMap;
-
-fn id(n: u128) -> Id {
-    Id::from_u128(0x40000000_0000_4000_8000_000000000000 + n)
-}
-
-fn reviewed<T>(oa: T, sa: T) -> Reviewed<T> {
-    Reviewed {
-        oa: Observed::Value(oa),
-        sa: Observed::Value(sa),
-    }
-}
-
-fn project(facets: Vec<FacetReview>) -> Project {
-    let mut project =
-        persistence::decode(include_bytes!("fixtures/v4-reviewed-prose.json")).unwrap();
-    project
-        .traces
-        .get_mut(&id(4))
-        .unwrap()
-        .baseline
-        .as_mut()
-        .unwrap()
-        .semantic = Some(SemanticBaseline { facets });
-    project
-}
-
-fn facets(project: &mut Project) -> &mut Vec<FacetReview> {
-    &mut project
-        .traces
-        .get_mut(&id(4))
-        .unwrap()
-        .baseline
-        .as_mut()
-        .unwrap()
-        .semantic
-        .as_mut()
-        .unwrap()
-        .facets
-}
-
-fn compile(source: String) -> CompiledSourceProject {
-    compile_bundle(
-        &SourceBundle {
-            entry: "project.arcadia".into(),
-            files: BTreeMap::from([("project.arcadia".into(), source)]),
-        },
-        ProjectLimits::default(),
-    )
-    .unwrap()
-}
-
-#[test]
-fn typed_historical_facets_roundtrip_deleted_references_and_all_leaf_categories() {
-    let row = MessageValue {
-        path: vec![id(91), id(92)],
-        field: id(93),
-        expression: "x + 1".into(),
-    };
-    let model = project(vec![
-        FacetReview::Data(DataReview::Constructor(reviewed(
-            DataConstructor::Integer,
-            DataConstructor::Real,
-        ))),
-        FacetReview::Data(DataReview::IntegerMinimum(Reviewed {
-            oa: Observed::Value(None),
-            sa: Observed::NotApplicable,
-        })),
-        FacetReview::Data(DataReview::RealMaximum(Reviewed {
-            oa: Observed::NotApplicable,
-            sa: Observed::Value(Some(1.5)),
-        })),
-        FacetReview::Field(FieldReview::Type(reviewed(
-            TypeRef::Named(id(90)),
-            TypeRef::Boolean,
-        ))),
-        FacetReview::Field(FieldReview::Default(reviewed(
-            Some(vec![DataValue::String(id(90).to_string())]),
-            None,
-        ))),
-        FacetReview::Member {
-            collection: ReferenceCollection::Steps,
-            keys: KeyPair {
-                oa: Some(id(91)),
-                sa: None,
-            },
-            review: reviewed(true, false),
-        },
-        FacetReview::Order {
-            collection: OrderedCollection::Steps,
-            review: reviewed(vec![id(91), id(92)], vec![]),
-        },
-        FacetReview::Annotation {
-            keys: KeyPair {
-                oa: Some(AnnotationKey::from(&row)),
-                sa: None,
-            },
-            review: reviewed(Some(row), None),
-        },
-        FacetReview::Binding {
-            keys: KeyPair {
-                oa: Some(id(94)),
-                sa: None,
-            },
-            review: reviewed(
-                Some(LifelineBinding {
-                    referenced: id(94),
-                    local: id(95),
-                }),
-                None,
-            ),
-        },
-        FacetReview::Literal {
-            keys: KeyPair {
-                oa: Some(id(90).to_string()),
-                sa: None,
-            },
-            review: reviewed(true, false),
-        },
-        FacetReview::Artifact {
-            keys: KeyPair {
-                oa: Some(id(96)),
-                sa: None,
-            },
-            review: ArtifactReview::Relation(reviewed(
-                ArtifactRelation::References,
-                ArtifactRelation::References,
-            )),
-        },
-    ]);
-    assert!(!model.contains(id(90)));
-    let source = language::format(&model);
-    assert!(source.starts_with("arcadia 5;"));
-    assert!(
-        source.contains(&format!("Named uuid \"{}\"", id(90))),
-        "{source}"
-    );
-    assert!(source.contains("sa NotApplicable;"));
-    assert!(source.contains("Value none;"));
-    assert!(source.contains(&format!("String \"{}\"", id(90))));
-    assert_eq!(language::parse(&source).unwrap(), model);
-    assert_eq!(compile(source).decoded.project, model);
-    assert_eq!(
-        persistence::decode(&serde_json::to_vec(&model).unwrap()).unwrap(),
-        model
-    );
-}
-
-#[test]
-fn historical_uuid_and_enum_tokens_are_contextual_and_text_remains_quoted() {
-    let model = project(vec![
-        FacetReview::Field(FieldReview::Type(reviewed(
-            TypeRef::Named(id(2)),
-            TypeRef::Boolean,
-        ))),
-        FacetReview::Data(DataReview::Unit(reviewed(id(2).to_string(), "m".into()))),
-    ]);
-    let source = language::format(&model);
-    let reference = format!("Named uuid \"{}\"", id(2));
-    for replacement in [format!("Named \"{}\"", id(2)), "Named @oa_dimension".into()] {
-        let invalid = source.replace(&reference, &replacement);
-        assert!(language::parse(&invalid).is_err(), "{invalid}");
-        assert!(
-            compile_bundle(
-                &SourceBundle {
-                    entry: "p.arcadia".into(),
-                    files: BTreeMap::from([("p.arcadia".into(), invalid)])
-                },
-                ProjectLimits::default()
-            )
-            .is_err()
-        );
-    }
-    let invalid_text = source.replace("Value \"m\";", &format!("Value uuid \"{}\";", id(2)));
-    assert!(language::parse(&invalid_text).is_err());
-    let invalid_enum = source.replace("Value Boolean;", "Value \"Boolean\";");
-    assert!(language::parse(&invalid_enum).is_err());
-    let invalid_live = source.replace("oa @oa_dimension;", &format!("oa uuid \"{}\";", id(2)));
-    assert!(language::parse(&invalid_live).is_err());
-    let invalid_prose = source.replace(
-        "name \"Approved OA name\";",
-        &format!("name uuid \"{}\";", id(2)),
-    );
-    assert!(language::parse(&invalid_prose).is_err());
-    // `uuid` remains an ordinary legal declaration alias after @.
-    assert!(language::parse(&source.replace("oa_dimension", "uuid")).is_ok());
-}
-
-#[test]
-fn semantic_values_remain_closed_typed_records_in_both_formats() {
-    let model = project(vec![FacetReview::Data(DataReview::IntegerMinimum(
-        reviewed(Some(0), None),
-    ))]);
-    let source = language::format(&model);
-    for invalid in [
-        source.replace("IntegerMinimum", "UnknownFacet"),
-        source.replace("Value 0;", "Value \"0\";"),
-        source.replace("facets [", "unexpected true; facets ["),
-    ] {
-        assert!(language::parse(&invalid).is_err(), "{invalid}");
-    }
-    let mut json = serde_json::to_value(&model).unwrap();
-    json["traces"][id(4).to_string()]["baseline"]["semantic"] = serde_json::json!({"facets": [{"Data": {"IntegerMinimum": {"oa": {"Value": "0"}, "sa": {"Value": null}}}}]});
-    assert!(persistence::decode(&serde_json::to_vec(&json).unwrap()).is_err());
-}
-
-#[test]
-fn facet_reordering_and_reidentification_keep_comments_with_typed_row_identity() {
-    let row = MessageValue {
-        path: vec![id(2)],
-        field: id(90),
-        expression: id(2).to_string(),
-    };
-    let model = project(vec![
-        FacetReview::Annotation {
-            keys: KeyPair {
-                oa: Some(AnnotationKey::from(&row)),
-                sa: None,
-            },
-            review: reviewed(Some(row), None),
-        },
-        FacetReview::Literal {
-            keys: KeyPair {
-                oa: Some(id(2).to_string()),
-                sa: None,
-            },
-            review: reviewed(true, false),
-        },
-        FacetReview::Field(FieldReview::Type(reviewed(
-            TypeRef::Named(id(2)),
-            TypeRef::Boolean,
-        ))),
-    ]);
-    let source = language::format(&model)
-        .replace("Annotation {", "Annotation { // annotation rationale")
-        .replace("Literal {", "Literal { // literal rationale")
-        .replace("Named uuid ", "Named uuid // historical type rationale\n");
-    let current = compile(source);
-    let mut prepared = prepare_command(
-        &current.decoded.project,
-        &Command::Reidentify(id(2), id(20)),
-    )
-    .unwrap();
-    facets(&mut prepared.project).reverse();
-    let updated = update_bundle_with_identity_map(
-        &current,
-        &prepared.project,
-        &prepared.identity_map,
-        ProjectLimits::default(),
-    )
-    .unwrap();
-    let text = &updated.bundle.files["project.arcadia"];
-    assert_eq!(updated.decoded.project, prepared.project);
-    assert!(
-        text.contains(&format!(
-            "Named uuid // historical type rationale\n\"{}\"",
-            id(20)
-        )),
-        "{text}"
-    );
-    let type_note = text.find("// historical type rationale").unwrap();
-    let literal_note = text.find("// literal rationale").unwrap();
-    let annotation_note = text.find("// annotation rationale").unwrap();
-    assert!(
-        type_note < literal_note && literal_note < annotation_note,
-        "{text}"
-    );
-    assert!(text.contains(&format!("expression \"{}\"", id(2))));
-    let FacetReview::Literal { keys, .. } = &facets(&mut prepared.project)[1] else {
-        panic!()
-    };
-    assert_eq!(
-        keys.oa,
-        Some(id(2).to_string()),
-        "UUID-shaped literal keys are text"
-    );
-    assert_eq!(
-        compile_bundle(&updated.bundle, ProjectLimits::default())
-            .unwrap()
-            .bundle,
-        updated.bundle
-    );
-}
-
-#[test]
-fn historical_reference_deletion_does_not_remove_the_review_or_create_a_live_alias() {
-    let mut model = project(vec![FacetReview::Field(FieldReview::Type(reviewed(
-        TypeRef::Named(id(90)),
-        TypeRef::Boolean,
-    )))]);
-    let mut former_type = model.elements[&id(2)].clone();
-    former_type.id = id(90);
-    former_type.alias = "former_type".into();
-    model.elements.insert(id(90), former_type);
-    let current = compile(language::format(&model));
-    let prepared = prepare_command(&current.decoded.project, &Command::Delete(id(90))).unwrap();
-    let updated = update_bundle_with_identity_map(
-        &current,
-        &prepared.project,
-        &prepared.identity_map,
-        ProjectLimits::default(),
-    )
-    .unwrap();
-    let source = &updated.bundle.files["project.arcadia"];
-    assert!(!updated.decoded.project.contains(id(90)));
-    assert!(!source.contains("@former_type"));
-    assert!(source.contains(&format!("Named uuid \"{}\"", id(90))));
-    assert_eq!(updated.decoded.project.traces, model.traces);
-    assert_eq!(language::parse(source).unwrap(), prepared.project);
-}
-
-#[test]
-fn included_historical_review_edits_save_and_reopen_without_rewriting_other_modules() {
-    use oa_core::source_files::{load_project, save_project};
-    let model = project(vec![FacetReview::Field(FieldReview::Type(reviewed(
-        TypeRef::Named(id(90)),
-        TypeRef::Boolean,
-    )))]);
-    let source = language::format(&model);
-    let trace_at = source.find("    trace ").unwrap();
-    let end = source.rfind('}').unwrap();
-    let entry = format!(
-        "{}    include \"reviews.arcadia\";\n}}\n",
-        &source[..trace_at]
-    );
-    let review =
-        source[trace_at..end].replace("Named uuid ", "Named uuid // deleted type retained\n");
-    let directory = tempfile::tempdir().unwrap();
-    let entry_path = directory.path().join("project.arcadia");
-    std::fs::write(&entry_path, &entry).unwrap();
-    std::fs::write(directory.path().join("reviews.arcadia"), &review).unwrap();
-    let snapshot = load_project(&entry_path, ProjectLimits::default()).unwrap();
-    let compiled = compile_bundle(&snapshot.reachable_bundle(), ProjectLimits::default()).unwrap();
-    assert_eq!(compiled.index.declarations[&id(4)].path, "reviews.arcadia");
-    let mut changed = compiled.decoded.project.clone();
-    let FacetReview::Field(FieldReview::Type(value)) = &mut facets(&mut changed)[0] else {
-        panic!()
-    };
-    value.sa = Observed::Value(TypeRef::String);
-    let updated = update_bundle(&compiled, &changed, ProjectLimits::default()).unwrap();
-    assert_eq!(updated.bundle.files["project.arcadia"], entry);
-    let saved = save_project(&snapshot, &updated, ProjectLimits::default()).unwrap();
-    let reopened = load_project(&entry_path, ProjectLimits::default()).unwrap();
-    assert_eq!(saved.bundle, reopened.bundle);
-    assert_eq!(
-        compile_bundle(&reopened.reachable_bundle(), ProjectLimits::default())
-            .unwrap()
-            .decoded
-            .project,
-        changed
-    );
-    assert_eq!(std::fs::read_to_string(&entry_path).unwrap(), entry);
-    assert!(reopened.bundle.files["reviews.arcadia"].contains("uuid // deleted type retained"));
-    assert!(!changed.contains(id(90)));
-}
-
-#[test]
-fn prepared_semantic_review_writes_back_and_preserves_the_accepted_target_difference() {
-    use oa_core::transitions::{TransitionDirection, TransitionMapping, TransitionRequest};
-    let model = project(vec![]);
-    let current = compile(language::format(&model).replace(
-        "baseline {",
-        "baseline { // prior prose review is independent",
-    ));
-    let mut transition = TransitionRequest::new(TransitionDirection::OaToSa, vec![id(2)]);
-    transition.mappings.push(TransitionMapping {
-        source: id(2),
-        target: Some(id(3)),
-        target_kind: None,
-    });
-    let mut request = SemanticTransitionRequest::new(transition);
-    request.reviews.push(SemanticReviewRequest {
-        source: id(2),
-        resolutions: vec![
-            FacetResolution {
-                facet: FacetSelector::Data(DataFacet::Unit),
-                decision: SemanticDecision::KeepTarget,
-            },
-            FacetResolution {
-                facet: FacetSelector::Header(HeaderFacet::Name),
-                decision: SemanticDecision::TakeSource,
-            },
-        ],
-        reset: vec![],
-    });
-    let plan = plan_semantic_transition(&current.decoded.project, request).unwrap();
-    assert!(plan.conflicts.is_empty(), "{:?}", plan.conflicts);
-    let prepared = prepare_semantic_transition(&current.decoded.project, &plan).unwrap();
-    let updated = update_bundle_with_identity_map(
-        &current,
-        &prepared.project,
-        &prepared.identity_map,
-        ProjectLimits::default(),
-    )
-    .unwrap();
-    assert_eq!(
-        updated.decoded.project.elements[&id(3)].name,
-        "OA dimension now"
-    );
-    assert!(
-        matches!(updated.decoded.project.elements[&id(3)].shared(), Some(SharedBody::DataType { unit, .. }) if unit == "ft")
-    );
-    assert!(
-        updated.bundle.files["project.arcadia"].contains("// prior prose review is independent")
-    );
-    let baseline = updated.decoded.project.traces[&id(4)]
-        .baseline
-        .as_ref()
-        .unwrap();
-    assert_eq!(baseline.oa.name, "Approved OA name");
-    assert!(
-        baseline
-            .semantic
-            .as_ref()
-            .unwrap()
-            .facets
-            .contains(&FacetReview::Data(DataReview::Unit(reviewed(
-                "m".into(),
-                "ft".into()
-            ))))
-    );
-    assert_eq!(
-        language::parse(&language::format(&updated.decoded.project)).unwrap(),
-        prepared.project
-    );
-    assert_eq!(
-        persistence::decode(&serde_json::to_vec(&updated.decoded.project).unwrap()).unwrap(),
-        prepared.project
-    );
-}

crates/oa-core/tests/r6_migration.rs

@@ -1,228 +0,0 @@
-use oa_core::{language, persistence, *};
-use serde_json::{Value, json};
-
-const SOURCE3: &str = include_str!("fixtures/v3-data-contract.arcadia");
-fn id(n: u128) -> Id {
-    Id::from_u128(n)
-}
-
-// Frozen JSON uses the same authored schema3 contract as the source fixture;
-// this helper never serializes current defaults under version3.
-fn original3() -> Value {
-    serde_json::from_str(include_str!("fixtures/v3-data-contract.json")).unwrap()
-}
-
-#[test]
-fn genuine_v3_preserves_typed_ports_and_allocates_deterministic_relationships() {
-    let old = original3();
-    let decoded = persistence::decode_with_report(&serde_json::to_vec(&old).unwrap()).unwrap();
-    let source = language::parse_with_report(SOURCE3).unwrap();
-    assert_eq!(decoded.project, source.project);
-    assert_eq!(decoded.migration, source.migration);
-    let project = &decoded.project;
-    let report = decoded.migration.as_ref().unwrap();
-    assert_eq!((report.from_schema, report.to_schema), (3, 5));
-    assert_eq!(project.identities().len(), 19);
-    assert!(report.preserved_ports.is_empty());
-    assert!(report.generated_endpoints.is_empty());
-    assert_eq!(report.generated_interface_allocations.len(), 2);
-    for allocation in &report.generated_interface_allocations {
-        assert_eq!(
-            allocation.id,
-            Id::new_v5(
-                &id(1),
-                format!(
-                    "v2-interface-item:{}:{}",
-                    allocation.source, allocation.target
-                )
-                .as_bytes()
-            )
-        );
-        assert_eq!(allocation.target, id(4));
-        assert_eq!(allocation.order, 0);
-        assert!(matches!(
-            project.relations[&allocation.id].body,
-            RelationBody::InterfaceItemAllocation {
-                transmission: TransmissionProtocol::Unspecified,
-                acquisition: AcquisitionProtocol::Unspecified,
-                ..
-            }
-        ));
-    }
-    let now = serde_json::to_value(project).unwrap();
-    for port in [id(11), id(12)] {
-        assert_eq!(
-            now["elements"][port.to_string()],
-            old["elements"][port.to_string()]
-        );
-    }
-    assert!(matches!(
-        project.elements[&id(4)].shared(),
-        Some(SharedBody::ExchangeItem {
-            kind: ExchangeItemKind::Information,
-            mechanism: ExchangeMechanism::Event,
-            supertype: None
-        })
-    ));
-    assert_eq!(report.unresolved_message_values.len(), 1);
-    assert!(
-        validation::validate(project)
-            .iter()
-            .any(|issue| issue.code == "message_value_ambiguous_path")
-    );
-    let canonical = language::format(project);
-    assert!(canonical.starts_with("arcadia 5;"));
-    let reopened = language::parse_with_report(&canonical).unwrap();
-    assert_eq!(&reopened.project, project);
-    assert!(reopened.migration.is_none());
-    assert_eq!(canonical, language::format(&reopened.project));
-}
-
-#[test]
-fn v3_changed_payloads_reject_schema4_fields_and_new_constructor_names() {
-    let mut old = original3();
-    old["elements"][id(4).to_string()]["body"]["Sa"]["Shared"]["ExchangeItem"]["mechanism"] =
-        json!("Flow");
-    assert!(persistence::decode(&serde_json::to_vec(&old).unwrap()).is_err());
-    let mut old = original3();
-    old["elements"][id(5).to_string()]["body"]["Sa"]["Shared"]["DataType"]["definition"] =
-        json!({"Record":{"supertype":null}});
-    assert!(persistence::decode(&serde_json::to_vec(&old).unwrap()).is_err());
-    let mut old = original3();
-    old["elements"][id(17).to_string()]["body"]["Sa"]["Shared"]["Occurrence"]["body"]["Exchange"]
-        ["values"][0]["path"] = json!([]);
-    assert!(persistence::decode(&serde_json::to_vec(&old).unwrap()).is_err());
-    let source = SOURCE3.replace("kind Event;", "kind Information; mechanism Flow;");
-    assert!(language::parse(&source).is_err());
-    let source = SOURCE3.replace(
-        "functional_exchange position_exchange",
-        "interface_item_allocation position_exchange",
-    );
-    assert!(language::parse(&source).is_err());
-}
-
-#[test]
-fn deterministic_allocation_id_collision_is_located_without_overwriting_any_object() {
-    let mut old = original3();
-    let collision = Id::new_v5(
-        &id(1),
-        format!("v2-interface-item:{}:{}", id(9), id(4)).as_bytes(),
-    );
-    old["artifact_links"][collision.to_string()] = json!({"id":collision,"alias":"retained_artifact","name":"Retain","description":"","owner":id(1),"relation":"References","uri":"docs/contract.md","revision":null,"fragment":null});
-    let error = persistence::decode(&serde_json::to_vec(&old).unwrap()).unwrap_err();
-    match error {
-        persistence::FileError::Model { issues, .. } => {
-            assert_eq!(issues[0].code, "identity_collision");
-            assert_eq!(issues[0].element, Some(id(9)));
-            assert_eq!(issues[0].field.as_deref(), Some("items"));
-        }
-        other => panic!("unexpected error {other}"),
-    }
-}
-
-#[test]
-fn unique_legacy_nested_value_is_qualified_and_physical_nature_is_not_guessed() {
-    let source = SOURCE3.replace("kind Event;", "kind Material;").replace(
-        "type_ref { Named @coordinate; }; }\n    }",
-        "type_ref String; }\n    }",
-    );
-    let decoded = language::parse_with_report(&source).unwrap();
-    assert!(matches!(
-        decoded.project.elements[&id(4)].shared(),
-        Some(SharedBody::ExchangeItem {
-            kind: ExchangeItemKind::Material,
-            mechanism: ExchangeMechanism::Unspecified,
-            ..
-        })
-    ));
-    let Some(SharedBody::Occurrence {
-        body: OccurrenceBody::Exchange { values, .. },
-        ..
-    }) = decoded.project.elements[&id(17)].shared()
-    else {
-        panic!()
-    };
-    assert_eq!(values[0].path, vec![id(7)]);
-    assert_eq!(values[0].expression, "navigation.latitude");
-}
-
-#[test]
-fn v1_and_frozen_v2_inputs_reach_four_through_the_shared_data_upgrade() {
-    let v2 =
-        persistence::decode_with_report(include_bytes!("fixtures/v2-coastal-rescue.json")).unwrap();
-    let text =
-        language::parse_with_report(include_str!("fixtures/v2-coastal-rescue.arcadia")).unwrap();
-    assert_eq!(v2.project, text.project);
-    assert_eq!(v2.migration, text.migration);
-    assert_eq!(v2.migration.unwrap().to_schema, 5);
-    let v1 = language::parse_with_report(
-        "arcadia 1; project \"Old\" id \"00000000-0000-0000-0000-000000000001\" {}",
-    )
-    .unwrap();
-    assert_eq!(v1.project.schema_version, 5);
-    assert_eq!(v1.migration.unwrap().from_schema, 1);
-}
-
-#[test]
-fn allocation_alias_collisions_are_stable_and_duplicate_legacy_payload_fields_reject() {
-    let mut old = original3();
-    let first = persistence::decode_with_report(&serde_json::to_vec(&old).unwrap()).unwrap();
-    let alias = first.migration.unwrap().generated_interface_allocations[0]
-        .alias
-        .clone();
-    old["artifact_links"][id(100).to_string()] = json!({"id":id(100),"alias":alias,"name":"Existing alias","description":"","owner":id(1),"relation":"References","uri":"docs/contract.md","revision":null,"fragment":null});
-    let bytes = serde_json::to_vec(&old).unwrap();
-    let migrated = persistence::decode_with_report(&bytes).unwrap();
-    let generated = &migrated
-        .migration
-        .as_ref()
-        .unwrap()
-        .generated_interface_allocations[0];
-    assert_ne!(generated.alias, alias);
-    assert!(generated.alias.starts_with(&alias));
-    assert_eq!(
-        migrated.project,
-        persistence::decode_with_report(&bytes).unwrap().project
-    );
-    let duplicate = include_str!("fixtures/v3-data-contract.json").replace(
-        "\"kind\": \"Event\"",
-        "\"kind\": \"Event\", \"kind\": \"Material\"",
-    );
-    assert!(
-        persistence::decode(duplicate.as_bytes())
-            .unwrap_err()
-            .to_string()
-            .contains("Duplicate field 'kind'")
-    );
-}
-
-#[test]
-fn recursive_legacy_record_paths_remain_ambiguous_instead_of_becoming_one_argument() {
-    let mut old = original3();
-    old["elements"][id(8).to_string()]["body"]["Sa"]["Shared"]["DataField"]["type_ref"] =
-        json!("String");
-    old["elements"][id(100).to_string()] = json!({"id":id(100),"alias":"next_coordinate","name":"Next coordinate","description":"","parent":id(5),"body":{"Sa":{"Shared":{"DataField":{"type_ref":{"Named":id(5)},"minimum":0,"maximum":1,"unit":""}}}}});
-    let decoded = persistence::decode_with_report(&serde_json::to_vec(&old).unwrap()).unwrap();
-    assert_eq!(
-        decoded
-            .migration
-            .as_ref()
-            .unwrap()
-            .unresolved_message_values
-            .len(),
-        1
-    );
-    let Some(SharedBody::Occurrence {
-        body: OccurrenceBody::Exchange { values, .. },
-        ..
-    }) = decoded.project.elements[&id(17)].shared()
-    else {
-        panic!()
-    };
-    assert!(values[0].path.is_empty());
-    assert!(
-        validation::validate(&decoded.project)
-            .iter()
-            .any(|issue| issue.code == "message_value_ambiguous_path")
-    );
-}

crates/oa-core/tests/r6_source.rs

@@ -1,215 +0,0 @@
-use oa_core::{language, source_project::*, *};
-use std::collections::BTreeMap;
-fn id(n: u128) -> Id {
-    Id::from_u128(n)
-}
-
-#[test]
-fn authored_v3_bundle_upgrade_preserves_includes_nested_ownership_comments_and_identity() {
-    let original = include_str!("fixtures/v3-data-contract.arcadia");
-    let header = original.find("    sa_function").unwrap();
-    let close = original.rfind('}').unwrap();
-    let entry = format!(
-        "{}    // Contracts stay in their original module.\n    include \"contracts.arcadia\";\n}}\n",
-        &original[..header]
-    );
-    let fragment = original[header..close].replace(
-        "items [@packet];",
-        "items [@ // interface contract decision\npacket];",
-    );
-    let bundle = SourceBundle {
-        entry: "project.arcadia".into(),
-        files: BTreeMap::from([
-            ("project.arcadia".into(), entry),
-            ("contracts.arcadia".into(), fragment),
-        ]),
-    };
-    let compiled = compile_bundle(&bundle, ProjectLimits::default()).unwrap();
-    assert_eq!(compiled.bundle.files.len(), 2);
-    assert!(compiled.bundle.files["project.arcadia"].contains("arcadia 5;"));
-    assert!(compiled.bundle.files["project.arcadia"].contains("include \"contracts.arcadia\";"));
-    for text in [
-        "// Contracts stay in their original module.",
-        "// Reused record parameters retain their own identities.",
-        "// interface contract decision",
-    ] {
-        assert!(
-            compiled
-                .bundle
-                .files
-                .values()
-                .any(|source| source.contains(text)),
-            "Lost {text}"
-        );
-    }
-    assert_eq!(compiled.index.lexical_owners[&id(6)], id(5));
-    assert_eq!(compiled.index.lexical_owners[&id(7)], id(4));
-    assert_eq!(compiled.index.lexical_owners[&id(8)], id(4));
-    assert_eq!(compiled.index.lexical_owners[&id(17)], id(14));
-    let report = compiled.decoded.migration.as_ref().unwrap();
-    assert_eq!(report.from_schema, 3);
-    for allocation in &report.generated_interface_allocations {
-        assert_eq!(
-            compiled.index.declarations[&allocation.id].path,
-            "contracts.arcadia"
-        );
-    }
-    assert!(
-        compiled
-            .diagnostics
-            .iter()
-            .any(|d| d.diagnostic.code == "message_value_ambiguous_path")
-    );
-    let second = compile_bundle(&compiled.bundle, ProjectLimits::default()).unwrap();
-    assert_eq!(second.bundle, compiled.bundle);
-    assert_eq!(second.decoded.project, compiled.decoded.project);
-    assert!(second.decoded.migration.is_none());
-    let mut renamed = compiled.decoded.project.clone();
-    renamed.elements.get_mut(&id(6)).unwrap().name = "Latitude degrees".into();
-    let updated = update_bundle(&compiled, &renamed, ProjectLimits::default()).unwrap();
-    assert_eq!(updated.index.lexical_owners, compiled.index.lexical_owners);
-    assert!(updated.bundle.files["contracts.arcadia"].contains("Latitude degrees"));
-    assert!(
-        bundle.files["project.arcadia"].contains("arcadia 3;"),
-        "Migration does not mutate the caller's draft"
-    );
-}
-
-#[test]
-fn schema4_typed_values_supertype_paths_and_protocols_roundtrip() {
-    let source = r#"arcadia 4; project data_contract "Data contract" {
-      sa_data_type bounded "Bounded" { definition { Integer { minimum -9223372036854775808; maximum 9223372036854775807; }; }; default { Integer -9223372036854775808; }; unit "m"; }
-      sa_data_type label_type "Label" { definition { String { minimum_length 1; maximum_length 4; }; }; default { String "航海"; }; }
-      sa_data_type base "Base" { definition { Record { supertype none; }; }; }
-      sa_data_type derived "Derived" { definition { Record { supertype @base; }; }; }
-      sa_exchange_item operation "Operation" { mechanism Operation;
-        sa_data_field value "Value" { type_ref { Named @bounded; }; direction In; storage Value; default [{ Integer 42; }]; }
-      }
-      sa_interface contract "Contract" { supertype none; }
-      interface_item_allocation member "Operation member" { source @contract; target @operation; transmission Synchronous; acquisition Accept; order 3; }
-      data_association association "Related records" { source @base; target @derived; source_role "parent"; target_role "children"; source_minimum 0; source_maximum 1; target_minimum 0; target_maximum none; source_navigable true; target_navigable true; }
-    }"#;
-    let parsed = language::parse(source).unwrap();
-    let formatted = language::format(&parsed);
-    assert!(formatted.contains("supertype @base"));
-    assert!(formatted.contains("transmission Synchronous"));
-    assert_eq!(language::parse(&formatted).unwrap(), parsed);
-    let compiled = compile_bundle(&format_bundle(&parsed), ProjectLimits::default()).unwrap();
-    assert_eq!(compiled.decoded.project, parsed);
-    assert!(compiled.decoded.migration.is_none());
-}
-
-#[test]
-fn omitted_ids_are_stabilized_before_allocation_identity_generation() {
-    let bundle=SourceBundle{entry:"project.arcadia".into(),files:BTreeMap::from([("project.arcadia".into(),"arcadia 3; project old_model \"Old\" { sa_exchange_item event_item \"Event\" { kind Event; } sa_interface contract \"Contract\" { items [@event_item]; } }".into())])};
-    let compiled = compile_bundle(&bundle, ProjectLimits::default()).unwrap();
-    let report = compiled.decoded.migration.as_ref().unwrap();
-    let allocation = &report.generated_interface_allocations[0];
-    assert_eq!(
-        allocation.id,
-        Id::new_v5(
-            &compiled.decoded.project.id,
-            format!(
-                "v2-interface-item:{}:{}",
-                allocation.source, allocation.target
-            )
-            .as_bytes()
-        )
-    );
-    let reopened = compile_bundle(&compiled.bundle, ProjectLimits::default()).unwrap();
-    assert_eq!(reopened.decoded.project, compiled.decoded.project);
-    assert_eq!(reopened.bundle, compiled.bundle);
-}
-
-#[test]
-fn inferring_a_legacy_path_keeps_rationale_inside_its_argument() {
-    let source = include_str!("fixtures/v3-data-contract.arcadia")
-        .replace(
-            "type_ref { Named @coordinate; }; }\n    }",
-            "type_ref String; }\n    }",
-        )
-        .replace(
-            "field @latitude; expression",
-            "field @latitude; // original argument rationale\nexpression",
-        );
-    let bundle = SourceBundle {
-        entry: "project.arcadia".into(),
-        files: BTreeMap::from([("project.arcadia".into(), source)]),
-    };
-    let compiled = compile_bundle(&bundle, ProjectLimits::default()).unwrap();
-    let source = &compiled.bundle.files["project.arcadia"];
-    let argument = &source[source.find("values [{").unwrap()..];
-    let argument = &argument[..argument.find('}').unwrap()];
-    assert!(
-        argument.contains("// original argument rationale"),
-        "{source}"
-    );
-    assert!(argument.contains("path [@origin]"), "{source}");
-    assert_eq!(compiled.index.lexical_owners[&id(17)], id(14));
-}
-
-#[test]
-fn qualified_value_reordering_and_path_reidentification_keep_each_arguments_comments() {
-    let mut project = language::parse(include_str!("fixtures/v3-data-contract.arcadia")).unwrap();
-    let Some(SharedBody::Occurrence {
-        body: OccurrenceBody::Exchange { values, .. },
-        ..
-    }) = project.elements.get_mut(&id(17)).unwrap().shared_mut()
-    else {
-        panic!()
-    };
-    *values = vec![
-        MessageValue {
-            path: vec![id(7)],
-            field: id(6),
-            expression: "origin value".into(),
-        },
-        MessageValue {
-            path: vec![id(8)],
-            field: id(6),
-            expression: "destination value".into(),
-        },
-    ];
-    let mut bundle = format_bundle(&project);
-    for source in bundle.files.values_mut() {
-        *source = source
-            .replace(
-                "expression \"origin value\";",
-                "expression \"origin value\"; // origin argument rationale",
-            )
-            .replace(
-                "expression \"destination value\";",
-                "expression \"destination value\"; // destination argument rationale",
-            );
-    }
-    let current = compile_bundle(&bundle, ProjectLimits::default()).unwrap();
-    let Some(SharedBody::Occurrence {
-        body: OccurrenceBody::Exchange { values, .. },
-        ..
-    }) = project.elements.get_mut(&id(17)).unwrap().shared_mut()
-    else {
-        panic!()
-    };
-    values.reverse();
-    let renamed = Id::from_u128(100);
-    let mut identities: BTreeMap<_, _> = project
-        .identities()
-        .into_iter()
-        .map(|(id, _)| (id, id))
-        .collect();
-    identities.insert(id(7), renamed);
-    reidentify(&mut project, id(7), renamed).unwrap();
-    project.elements.get_mut(&renamed).unwrap().alias = "revised_origin".into();
-    let result =
-        update_bundle_with_identity_map(&current, &project, &identities, ProjectLimits::default())
-            .unwrap();
-    let source = &result.bundle.files[&result.index.declarations[&id(17)].path];
-    let destination = source.find("// destination argument rationale").unwrap();
-    let origin = source.find("// origin argument rationale").unwrap();
-    assert!(
-        destination < origin,
-        "Distinct uses of the same terminal field must reorder as complete argument annotations: {source}"
-    );
-    assert!(source[origin..].contains("path [@revised_origin]"));
-    assert_eq!(result.decoded.project, project);
-}

crates/oa-core/tests/release_ports.rs

@@ -447,12 +447,11 @@ fn standard_interface_roles_do_not_follow_message_direction_and_kind_mixing_is_r
     p = execute_batch(&p, &plan_component_exchange(&p, &req).unwrap()).unwrap();
     let (source, target) = p.relations[&boundary].body.endpoints();
     let interface = add(&mut p, Kind::Interface, Layer::Sa, "Service");
-    p.relate(
-        RelationKind::InterfaceItemAllocation,
-        "Interface payload",
-        interface,
-        item,
-    );
+    *p.elements
+        .get_mut(&interface)
+        .unwrap()
+        .shared_mut()
+        .unwrap() = SharedBody::Interface { items: vec![item] };
     let requirement = p.relate(
         RelationKind::InterfaceRequirement,
         "Caller requires service",
@@ -500,12 +499,11 @@ fn legacy_split_preserves_original_identity_prose_interface_artifact_constraint_
     let (mut p, a, b, item, forward) = fixture();
     let (old, _) = endpoints(&p, forward);
     let interface = add(&mut p, Kind::Interface, Layer::Sa, "Original interface");
-    p.relate(
-        RelationKind::InterfaceItemAllocation,
-        "Interface payload",
-        interface,
-        item,
-    );
+    *p.elements
+        .get_mut(&interface)
+        .unwrap()
+        .shared_mut()
+        .unwrap() = SharedBody::Interface { items: vec![item] };
     p.elements.get_mut(&old).unwrap().description = "Original bidirectional rationale".into();
     *p.elements.get_mut(&old).unwrap().shared_mut().unwrap() = SharedBody::Port {
         contract: PortContract::Legacy,
@@ -661,12 +659,11 @@ fn directed_legacy_resolution_retains_unclassified_interface_and_role_identity()
     let (mut p, _, _, item, fe) = fixture();
     let output = endpoints(&p, fe).0;
     let interface = add(&mut p, Kind::Interface, Layer::Sa, "Original service");
-    p.relate(
-        RelationKind::InterfaceItemAllocation,
-        "Interface payload",
-        interface,
-        item,
-    );
+    *p.elements
+        .get_mut(&interface)
+        .unwrap()
+        .shared_mut()
+        .unwrap() = SharedBody::Interface { items: vec![item] };
     *p.elements.get_mut(&output).unwrap().shared_mut().unwrap() = SharedBody::Port {
         contract: PortContract::Legacy,
         legacy: Some(LegacyPortContract {

crates/oa-core/tests/release_scenarios.rs

@@ -94,9 +94,7 @@ fn fixture(layer: Layer) -> Fixture {
         .add_element(Kind::DataType, layer, "Request record", None)
         .unwrap();
     *p.elements.get_mut(&record).unwrap().shared_mut().unwrap() = SharedBody::DataType {
-        definition: DataTypeDefinition::Record { supertype: None },
-        default: None,
-        unit: String::new(),
+        definition: DataTypeDefinition::Record,
     };
     let field = p
         .add_element(Kind::DataField, layer, "Requested level", Some(record))
@@ -162,7 +160,6 @@ fn fixture(layer: Layer) -> Fixture {
     }) = p.elements.get_mut(&call).unwrap().shared_mut()
     {
         values.push(MessageValue {
-            path: vec![payload],
             field,
             expression: "requested_level".into(),
         });

crates/oa-core/tests/source_files.rs

@@ -5,7 +5,7 @@ fn setup() -> tempfile::TempDir {
     let directory = tempfile::tempdir().unwrap();
     fs::write(
         directory.path().join("project.arcadia"),
-        "arcadia 5; project p \"P\" { include \"parts/a.arcadia\"; }\n",
+        "arcadia 3; project p \"P\" { include \"parts/a.arcadia\"; }\n",
     )
     .unwrap();
     fs::create_dir(directory.path().join("parts")).unwrap();
@@ -59,7 +59,7 @@ fn loading_keeps_original_no_uuid_bytes_and_saving_stabilizes_exactly_once() {
 fn invalid_and_missing_includes_keep_editable_text_and_located_diagnostics() {
     let directory = setup();
     let entry = directory.path().join("project.arcadia");
-    fs::write(&entry, "arcadia 5; project p \"P\" {\n include \"missing.arcadia\";\n include \"parts/a.arcadia\";\n}\n").unwrap();
+    fs::write(&entry, "arcadia 3; project p \"P\" {\n include \"missing.arcadia\";\n include \"parts/a.arcadia\";\n}\n").unwrap();
     fs::write(
         directory.path().join("parts/a.arcadia"),
         "oa_activity a \"A\" { invalid",
@@ -102,7 +102,7 @@ fn discovery_never_refreshes_drafts_and_preserves_detached_buffers() {
     let overlays = BTreeMap::from([
         (
             "project.arcadia".into(),
-            "arcadia 5; project p \"P\" { include \"new.arcadia\"; }".into(),
+            "arcadia 3; project p \"P\" { include \"new.arcadia\"; }".into(),
         ),
         (
             "parts/a.arcadia".into(),
@@ -176,7 +176,7 @@ fn new_destinations_require_explicit_missing_expectations_and_reject_collisions(
         files: BTreeMap::from([
             (
                 "project.arcadia".into(),
-                "arcadia 5; project p \"P\" { include \"child.arcadia\"; }".into(),
+                "arcadia 3; project p \"P\" { include \"child.arcadia\"; }".into(),
             ),
             ("child.arcadia".into(), "oa_activity a \"A\" {}".into()),
         ]),
@@ -256,7 +256,7 @@ fn physical_hard_link_aliases_are_rejected() {
     .unwrap();
     fs::write(
         directory.path().join("project.arcadia"),
-        "arcadia 5; project p \"P\" { include \"parts/a.arcadia\"; include \"alias.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"parts/a.arcadia\"; include \"alias.arcadia\"; }",
     )
     .unwrap();
     assert!(matches!(
@@ -286,7 +286,7 @@ fn symlinks_to_outside_or_inside_project_are_rejected() {
         std::os::unix::fs::symlink(&destination, &link).unwrap();
         fs::write(
             directory.path().join("project.arcadia"),
-            "arcadia 5; project p \"P\" { include \"alias.arcadia\"; }",
+            "arcadia 3; project p \"P\" { include \"alias.arcadia\"; }",
         )
         .unwrap();
         let loaded = load_project(

crates/oa-core/tests/source_identity_updates.rs

@@ -6,10 +6,10 @@ fn source() -> CompiledSourceProject {
         &SourceBundle {
             entry: "project.arcadia".into(),
             files: BTreeMap::from([
-                ("project.arcadia".into(), "arcadia 5; project p \"Identity review\" { include \"team/first.arcadia\"; include \"team/second.arcadia\"; include \"contracts.arcadia\"; }".into()),
+                ("project.arcadia".into(), "arcadia 3; project p \"Identity review\" { include \"team/first.arcadia\"; include \"team/second.arcadia\"; include \"contracts.arcadia\"; }".into()),
                 ("team/first.arcadia".into(), "// Rationale for first\nsa_exchange_item first \"First\" { description \"First rationale\"; }\n".into()),
                 ("team/second.arcadia".into(), "// Rationale for second\nsa_exchange_item second \"Second\" {}\n".into()),
-                ("contracts.arcadia".into(), "sa_event contract \"Contract\" { body { Signal { items [\n @first // first item rationale\n ,\n @second // second item rationale\n ]; }; }; }\n".into()),
+                ("contracts.arcadia".into(), "sa_interface contract \"Contract\" { items [\n @first // first item rationale\n ,\n @second // second item rationale\n ]; }\n".into()),
             ]),
         },
         ProjectLimits::default(),
@@ -91,9 +91,8 @@ fn identity_swap_and_reorder_keep_both_declarations_and_item_comments_with_origi
     reidentify(&mut candidate, second, first).unwrap();
     reidentify(&mut candidate, temporary, second).unwrap();
     let contract = find(&candidate, "contract");
-    let Some(SharedBody::Event {
-        body: EventBody::Signal { items },
-    }) = candidate.elements.get_mut(&contract).unwrap().shared_mut()
+    let Some(SharedBody::Interface { items }) =
+        candidate.elements.get_mut(&contract).unwrap().shared_mut()
     else {
         panic!("interface")
     };

crates/oa-core/tests/source_nested_updates.rs

@@ -5,7 +5,7 @@ fn compile(a: &str, b: &str) -> CompiledSourceProject {
     compile_bundle(&SourceBundle {
         entry: "project.arcadia".into(),
         files: BTreeMap::from([
-            ("project.arcadia".into(), "arcadia 5; project p \"Nested writeback\" { include \"a.arcadia\"; include \"b.arcadia\"; }\n".into()),
+            ("project.arcadia".into(), "arcadia 3; project p \"Nested writeback\" { include \"a.arcadia\"; include \"b.arcadia\"; }\n".into()),
             ("a.arcadia".into(), a.into()), ("b.arcadia".into(), b.into()),
         ]),
     }, ProjectLimits::default()).unwrap()

crates/oa-core/tests/source_project.rs

@@ -30,7 +30,7 @@ fn id(project: &Project, alias: &str) -> Id {
 #[test]
 fn route_edits_keep_diagram_file_ownership_and_comments_with_edge_identity() {
     let input = bundle(
-        "arcadia 5; project p \"Routing\" { include \"views.arcadia\"; include \"work.arcadia\"; }",
+        "arcadia 3; project p \"Routing\" { include \"views.arcadia\"; include \"work.arcadia\"; }",
         &[
             (
                 "work.arcadia",
@@ -95,7 +95,7 @@ diagram review "Review" {
 #[test]
 fn invalid_cross_file_route_references_and_geometry_locate_the_authored_view() {
     let mut input = bundle(
-        "arcadia 5; project p \"Routing\" { include \"views.arcadia\"; include \"work.arcadia\"; }",
+        "arcadia 3; project p \"Routing\" { include \"views.arcadia\"; include \"work.arcadia\"; }",
         &[
             (
                 "work.arcadia",
@@ -127,7 +127,7 @@ fn invalid_cross_file_route_references_and_geometry_locate_the_authored_view() {
 
 fn typed() -> SourceBundle {
     bundle(
-        "arcadia 5; project test_model \"航海\" {\n include \"exchanges.arcadia\";\n include \"work/send.arcadia\";\n include \"work/receive.arcadia\";\n include \"types.arcadia\";\n}",
+        "arcadia 3; project test_model \"航海\" {\n include \"exchanges.arcadia\";\n include \"work/send.arcadia\";\n include \"work/receive.arcadia\";\n include \"types.arcadia\";\n}",
         &[
             (
                 "exchanges.arcadia",
@@ -194,7 +194,7 @@ fn cross_file_typed_ports_global_forward_references_and_stable_ids() {
 #[test]
 fn advisory_lint_locations_refer_to_raw_drafts_before_identity_stabilization() {
     let input = bundle(
-        "arcadia 5; project p \"P\" { include \"work.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"work.arcadia\"; }",
         &[(
             "work.arcadia",
             "sa_function first \"First\" {}\nsa_function second \"Second\" {}\n",
@@ -228,7 +228,7 @@ fn advisory_lint_locations_refer_to_raw_drafts_before_identity_stabilization() {
 #[test]
 fn source_errors_keep_exact_fragment_unicode_positions() {
     let input = bundle(
-        "arcadia 5; project p \"P\" { include \"child.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"child.arcadia\"; }",
         &[(
             "child.arcadia",
             "// Пример\nsa_function child \"航海\" { parent @missing; }",
@@ -274,7 +274,7 @@ fn duplicate_alias_and_identity_report_both_files_including_project_identity() {
         ),
     ] {
         let input = bundle(
-            "arcadia 5; project p \"P\" { include \"a.arcadia\"; include \"b.arcadia\"; }",
+            "arcadia 3; project p \"P\" { include \"a.arcadia\"; include \"b.arcadia\"; }",
             &[("a.arcadia", left), ("b.arcadia", right)],
         );
         let error = compile_bundle(&input, ProjectLimits::default())
@@ -285,7 +285,7 @@ fn duplicate_alias_and_identity_report_both_files_including_project_identity() {
         assert_eq!(error.related[0].path, "a.arcadia");
     }
     let input = bundle(
-        "arcadia 5; project p \"P\" { include \"child.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"child.arcadia\"; }",
         &[("child.arcadia", "oa_activity p \"Collision\" {}")],
     );
     let error = compile_bundle(&input, ProjectLimits::default())
@@ -297,7 +297,7 @@ fn duplicate_alias_and_identity_report_both_files_including_project_identity() {
 #[test]
 fn includes_are_once_only_and_cycles_missing_and_unreachable_files_are_located() {
     let mut input = bundle(
-        "arcadia 5; project p \"P\" { include \"sub/a.arcadia\"; include \"sub/b.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"sub/a.arcadia\"; include \"sub/b.arcadia\"; }",
         &[
             ("sub/a.arcadia", "include \"../shared.arcadia\";"),
             ("sub/b.arcadia", "include \"../shared.arcadia\";"),
@@ -356,7 +356,7 @@ fn portable_paths_reject_escapes_devices_urls_and_case_collisions() {
     );
     assert!(resolve_include("../bad.arcadia", "a.arcadia").is_err());
     let input = bundle(
-        "arcadia 5; project p \"P\" {}",
+        "arcadia 3; project p \"P\" {}",
         &[("A.arcadia", ""), ("a.arcadia", "")],
     );
     assert_eq!(
@@ -370,7 +370,7 @@ fn portable_paths_reject_escapes_devices_urls_and_case_collisions() {
 #[test]
 fn project_admission_is_aggregate_and_precedes_global_resolution() {
     let input = bundle(
-        "arcadia 5; project p \"P\" { include \"a.arcadia\"; include \"b.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"a.arcadia\"; include \"b.arcadia\"; }",
         &[
             ("a.arcadia", "oa_activity one \"One\" { parent @missing; }"),
             ("b.arcadia", "oa_activity two \"Two\" {}"),
@@ -591,7 +591,7 @@ fn failed_update_preserves_candidate_and_rejects_stale_index() {
 
 #[test]
 fn single_string_and_legacy_apis_remain_explicit_and_filesystem_free() {
-    let source = "arcadia 5; project p \"P\" { include \"missing.arcadia\"; }";
+    let source = "arcadia 3; project p \"P\" { include \"missing.arcadia\"; }";
     assert!(
         language::parse(source).unwrap_err()[0]
             .message
@@ -681,7 +681,7 @@ fn json_bundle_rejects_duplicate_file_keys_and_unknown_fields() {
 #[test]
 fn generated_id_insertion_handles_adjacent_header_tokens_and_remains_exactly_indexed() {
     let input = bundle(
-        "arcadia 5;project p\"P\"{include \"child.arcadia\";}",
+        "arcadia 3;project p\"P\"{include \"child.arcadia\";}",
         &[(
             "child.arcadia",
             "oa_activity a\"A\"{}diagram d\"D\"{}node n{diagram @d;element @a;}",
@@ -703,7 +703,7 @@ fn generated_id_insertion_handles_adjacent_header_tokens_and_remains_exactly_ind
 #[test]
 fn duplicate_include_edges_count_toward_admission_and_ordered_references_are_aggregate() {
     let input = bundle(
-        "arcadia 5; project p \"P\" { include \"a.arcadia\"; include \"a.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"a.arcadia\"; include \"a.arcadia\"; }",
         &[("a.arcadia", "")],
     );
     assert_eq!(
@@ -720,7 +720,7 @@ fn duplicate_include_edges_count_toward_admission_and_ordered_references_are_agg
         "project_limit"
     );
     let input = bundle(
-        "arcadia 5; project p \"P\" { include \"a.arcadia\"; include \"b.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"a.arcadia\"; include \"b.arcadia\"; }",
         &[
             (
                 "a.arcadia",
@@ -763,7 +763,7 @@ fn include_inspection_reuses_strict_entry_fragment_syntax_and_real_spans() {
         &source[span.start..span.end],
         "include \"../shared.arcadia\";"
     );
-    let entry = "arcadia 5; project p \"P\" { include \"sub/work.arcadia\"; }";
+    let entry = "arcadia 3; project p \"P\" { include \"sub/work.arcadia\"; }";
     assert_eq!(
         inspect_includes("project.arcadia", entry, true, ProjectLimits::default()).unwrap()[0]
             .target,
@@ -829,7 +829,7 @@ fn comments(source: &str) -> Vec<String> {
 
 #[test]
 fn scalar_header_guard_and_project_edits_preserve_exact_crlf_trivia_and_escape_spelling() {
-    let entry = "arcadia 5;\r\nproject p // project title\r\n \"Original project\" {\r\n description // project reason\r\n \"Before\";\r\n include \"behavior.arcadia\";\r\n}\r\n";
+    let entry = "arcadia 3;\r\nproject p // project title\r\n \"Original project\" {\r\n description // project reason\r\n \"Before\";\r\n include \"behavior.arcadia\";\r\n}\r\n";
     let source = "oa_state_machine machine \"Machine\" {}\r\noa_region region_one \"Region\" { parent @machine; }\r\noa_state first \"First\" { parent @region_one; }\r\noa_state second \"Second\" { parent @region_one; }\r\nstate_transition route // route title\r\n \"Original transition\" {\r\n\tguard // feasibility\r\n\t \"old guard\"; // retain explanation\r\n\tdescription \"Keep\\u0020spelling\";\r\n\tsource @ // endpoint proof\r\n first; target @second;\r\n}\r\n";
     let current = compile(&bundle(entry, &[("behavior.arcadia", source)]));
     let mut project = current.decoded.project.clone();
@@ -864,7 +864,7 @@ fn scalar_header_guard_and_project_edits_preserve_exact_crlf_trivia_and_escape_s
 #[test]
 fn alias_updates_touch_only_header_and_reference_tokens_even_with_comments_after_at() {
     let input = bundle(
-        "arcadia 5; project p \"P\" { include \"work.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"work.arcadia\"; }",
         &[(
             "work.arcadia",
             "oa_activity root_work // root rationale\n \"Root\\u0020name\" { description \"root_work is prose\"; }\noa_activity child \"Child\" { parent @ // parent proof\n root_work; }\n",
@@ -887,7 +887,7 @@ fn alias_updates_touch_only_header_and_reference_tokens_even_with_comments_after
 #[test]
 fn omitted_defaults_stay_omitted_and_new_fields_do_not_reformat_surviving_fields() {
     let input = bundle(
-        "arcadia 5; project p \"P\" { include \"work.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"work.arcadia\"; }",
         &[(
             "work.arcadia",
             "oa_activity work \"Work\" {\r\n\t// owner rationale\r\n\tparent   none ; // preserve spacing\r\n}\r\n",
@@ -913,7 +913,7 @@ fn omitted_defaults_stay_omitted_and_new_fields_do_not_reformat_surviving_fields
 #[test]
 fn kind_change_removes_field_syntax_but_keeps_its_comments_and_other_fields() {
     let input = bundle(
-        "arcadia 5; project p \"P\" { include \"item.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"item.arcadia\"; }",
         &[(
             "item.arcadia",
             "oa_exchange_item item \"Item\" {\n description  \"Keep\\u0020this\" ; // description note\n kind // classification rationale\n Information ;\n parent none;\n}\n",
@@ -953,7 +953,7 @@ fn significant_words(source: &str) -> Vec<String> {
 #[test]
 fn constructor_tag_changes_retain_shared_nested_fields_and_removed_field_comments() {
     let input = bundle(
-        "arcadia 5; project p \"P\" { include \"event.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"event.arcadia\"; }",
         &[(
             "event.arcadia",
             "oa_event timer \"Timer\" { body { Time // time rationale\n { expression // expression rationale\n \"before\" ; kind After; // clock rationale\n }; }; }\n",
@@ -986,7 +986,7 @@ fn constructor_tag_changes_retain_shared_nested_fields_and_removed_field_comment
 #[test]
 fn scalar_record_constructor_changes_keep_comments_inside_removed_values() {
     let input = bundle(
-        "arcadia 5; project p \"P\" { include \"ports.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"ports.arcadia\"; }",
         &[(
             "ports.arcadia",
             "sa_function work \"Work\" {}\nsa_port input \"Input\" { parent @work; contract Legacy; // contract rationale\n legacy { direction In; // direction rationale\n interface none; // interface rationale\n }; }\n",
@@ -1017,10 +1017,10 @@ fn scalar_record_constructor_changes_keep_comments_inside_removed_values() {
 #[test]
 fn reference_list_reordering_carries_item_comments_and_alias_spelling_with_identity() {
     let input = bundle(
-        "arcadia 5; project p \"P\" { include \"types.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"types.arcadia\"; }",
         &[(
             "types.arcadia",
-            "sa_exchange_item a \"A\" {} sa_exchange_item b \"B\" {}\nsa_event service \"Service\" { body { Signal { items [\n // before A\n @ // A reference rationale\n a // after A\n ,\n // before B\n @b // after B\n ]; }; }; }\n",
+            "sa_exchange_item a \"A\" {} sa_exchange_item b \"B\" {}\nsa_interface service \"Service\" { items [\n // before A\n @ // A reference rationale\n a // after A\n ,\n // before B\n @b // after B\n ]; }\n",
         )],
     );
     let current = compile(&input);
@@ -1029,9 +1029,8 @@ fn reference_list_reordering_carries_item_comments_and_alias_spelling_with_ident
     let b = id(&project, "b");
     let service = id(&project, "service");
     project.elements.get_mut(&a).unwrap().alias = "renamed_a".into();
-    if let Some(SharedBody::Event {
-        body: EventBody::Signal { items },
-    }) = project.elements.get_mut(&service).unwrap().shared_mut()
+    if let Some(SharedBody::Interface { items }) =
+        project.elements.get_mut(&service).unwrap().shared_mut()
     {
         *items = vec![b, a];
     } else {
@@ -1052,10 +1051,10 @@ fn reference_list_reordering_carries_item_comments_and_alias_spelling_with_ident
 #[test]
 fn removed_list_items_and_declarations_keep_comments_as_enclosing_annotations() {
     let input = bundle(
-        "arcadia 5; project p \"P\" { include \"types.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"types.arcadia\"; }",
         &[(
             "types.arcadia",
-            "sa_exchange_item a \"A\" { // declaration explanation\n } sa_exchange_item b \"B\" {}\nsa_event service \"Service\" { body { Signal { items [\n // explanation for removed A\n @a,\n // explanation for retained B\n @b ]; }; }; }\n",
+            "sa_exchange_item a \"A\" { // declaration explanation\n } sa_exchange_item b \"B\" {}\nsa_interface service \"Service\" { items [\n // explanation for removed A\n @a,\n // explanation for retained B\n @b ]; }\n",
         )],
     );
     let current = compile(&input);
@@ -1064,9 +1063,8 @@ fn removed_list_items_and_declarations_keep_comments_as_enclosing_annotations()
     let b = id(&project, "b");
     let service = id(&project, "service");
     project.elements.remove(&a);
-    if let Some(SharedBody::Event {
-        body: EventBody::Signal { items },
-    }) = project.elements.get_mut(&service).unwrap().shared_mut()
+    if let Some(SharedBody::Interface { items }) =
+        project.elements.get_mut(&service).unwrap().shared_mut()
     {
         *items = vec![b];
     } else {
@@ -1104,7 +1102,7 @@ oa_occurrence message "Message" { parent @conversation; body { Exchange {
  }; }; }
 "#;
     let current = compile(&bundle(
-        "arcadia 5; project p \"P\" { include \"conversation.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"conversation.arcadia\"; }",
         &[("conversation.arcadia", source)],
     ));
     let mut project = current.decoded.project.clone();
@@ -1153,7 +1151,7 @@ oa_occurrence message "Message" { parent @conversation; body { Exchange {
 #[test]
 fn added_list_items_empty_lists_and_literal_changes_preserve_existing_annotations() {
     let input = bundle(
-        "arcadia 5; project p \"P\" { include \"types.arcadia\"; }",
+        "arcadia 3; project p \"P\" { include \"types.arcadia\"; }",
         &[(
             "types.arcadia",
             "oa_data_type values \"Values\" { definition { Enumeration { literals [ // enumeration rationale\n ]; }; }; }\n",
@@ -1162,7 +1160,7 @@ fn added_list_items_empty_lists_and_literal_changes_preserve_existing_annotation
     let empty = compile(&input);
     let mut project = empty.decoded.project.clone();
     let values = id(&project, "values");
-    if let Some(SharedBody::DataType { definition, .. }) =
+    if let Some(SharedBody::DataType { definition }) =
         project.elements.get_mut(&values).unwrap().shared_mut()
     {
         *definition = DataTypeDefinition::Enumeration {
@@ -1187,7 +1185,7 @@ fn added_list_items_empty_lists_and_literal_changes_preserve_existing_annotation
                 .replace("\"Beta\"", "\"Beta\" // beta explanation\n"),
         );
     let annotated = compile(&annotated);
-    if let Some(SharedBody::DataType { definition, .. }) =
+    if let Some(SharedBody::DataType { definition }) =
         project.elements.get_mut(&values).unwrap().shared_mut()
     {
         *definition = DataTypeDefinition::Enumeration {

crates/oa-core/tests/workflows.rs

@@ -42,7 +42,6 @@ fn make_trace(p: &mut Project, oa: Id, sa: Id) -> Id {
         baseline: Some(TraceBaseline {
             oa: p.properties(oa).unwrap(),
             sa: p.properties(sa).unwrap(),
-            semantic: None,
         }),
     };
     p.traces.insert(id, t);
@@ -329,12 +328,11 @@ fn items_ports_interfaces_and_exchange_allocation_are_typed() {
     let f2 = add(&mut p, Kind::Function, Layer::Sa, "Receive", None);
     let item = add(&mut p, Kind::ExchangeItem, Layer::Sa, "Message", None);
     let interface = add(&mut p, Kind::Interface, Layer::Sa, "Link interface", None);
-    p.relate(
-        RelationKind::InterfaceItemAllocation,
-        "Interface payload",
-        interface,
-        item,
-    );
+    *p.elements
+        .get_mut(&interface)
+        .unwrap()
+        .shared_mut()
+        .unwrap() = SharedBody::Interface { items: vec![item] };
     let port = |p: &mut Project, name: &str, parent, direction| {
         let id = Id::new_v4();
         let contract = if p.elements[&parent].kind() == Kind::Function {
@@ -742,9 +740,6 @@ fn reidentifying_data_types_and_function_ports_updates_every_typed_reference() {
         minimum: 0,
         maximum: None,
         unit: "items".into(),
-        direction: ParameterDirection::Unspecified,
-        storage: FieldStorage::Value,
-        default: None,
     };
     let function = add(&mut p, Kind::Function, Layer::Sa, "Function", None);
     let other = add(&mut p, Kind::Function, Layer::Sa, "Other", None);
@@ -809,40 +804,8 @@ fn every_demo_identity_can_be_remapped_and_deleted_without_dangling_references()
             "Reidentification must preserve all values and order"
         );
         if id != p.id {
-            let deleted = if p
-                .relations
-                .get(&id)
-                .is_some_and(|r| r.kind() == RelationKind::InterfaceItemAllocation)
-            {
-                // An explicitly empty interface cannot silently accept the
-                // still-carried payload. Removing its definition needs a
-                // reviewed edit of that dependent contract in the same batch.
-                let mut session = Session::new(p.clone());
-                assert!(
-                    session
-                        .execute(Command::Delete(id))
-                        .unwrap_err()
-                        .0
-                        .contains("port_interface_items")
-                );
-                assert_eq!(session.project(), &p);
-                assert_eq!(session.revision(), 0);
-                let item = p.relations[&id].target();
-                let mut commands = vec![Command::Delete(id)];
-                commands.extend(
-                    p.relations
-                        .values()
-                        .filter(|r| {
-                            r.kind() == RelationKind::BoundaryExchange
-                                && r.body.items().contains(&item)
-                        })
-                        .map(|r| Command::Delete(r.id)),
-                );
-                execute_batch(&p, &commands).unwrap()
-            } else {
-                execute_batch(&p, &[Command::Delete(id)])
-                    .unwrap_or_else(|err| panic!("Delete {id}: {err}"))
-            };
+            let deleted = execute_batch(&p, &[Command::Delete(id)])
+                .unwrap_or_else(|err| panic!("Delete {id}: {err}"));
             accepted(&deleted);
         }
     }
@@ -927,15 +890,13 @@ fn demo_has_both_layers_complete_contracts_and_no_checks() {
     assert!(p.elements.values().any(|e| matches!(
         e.shared(),
         Some(SharedBody::ExchangeItem {
-            kind: ExchangeItemKind::Material,
-            ..
+            kind: ExchangeItemKind::Material
         })
     )));
     assert!(p.elements.values().any(|e| matches!(
         e.shared(),
         Some(SharedBody::ExchangeItem {
-            kind: ExchangeItemKind::Energy,
-            ..
+            kind: ExchangeItemKind::Energy
         })
     )));
 }

crates/oa-desktop/src/app.rs

@@ -106,7 +106,6 @@ pub enum Message {
     SelectProject,
     Search(String),
     StartTransition,
-    StartSemanticReview(Id),
     Workflow(crate::workflow::Event),
     CollapseExplorer(Id),
     ExplorerGroup(crate::explorer::Group),
@@ -116,7 +115,6 @@ pub enum Message {
     BrowseGroup(crate::explorer::Group),
     ExplorerPage(usize),
     CreateKind(Kind),
-    Data(crate::data_view::Event),
     Add(bool),
     AddRelation,
     PortAction(crate::port_workflow::Action),
@@ -129,8 +127,6 @@ pub enum Message {
     Field(String, String),
     FieldText(String, text_editor::Action),
     FieldShape(String, Value),
-    FieldAppend(String, Value),
-    FieldValuePath(String, crate::data_values::FieldPathKey),
     FieldVariant(String, Value),
     FieldArray(String, Option<usize>, i32),
     Apply,
@@ -208,7 +204,6 @@ pub struct App {
     pub page: Page,
     pub guide: crate::guide::State,
     pub behavior: crate::behavior::State,
-    pub data_state: crate::data_view::State,
     pub inspector_tab: crate::navigation::InspectorTab,
     pub layer: Layer,
     pub selected: Id,
@@ -297,7 +292,6 @@ impl App {
             page: Page::Diagram,
             guide: crate::guide::State::default(),
             behavior: Default::default(),
-            data_state: Default::default(),
             inspector_tab: Default::default(),
             layer,
             selected,
@@ -770,8 +764,6 @@ impl App {
                 Message::Field(..)
                     | Message::FieldText(..)
                     | Message::FieldShape(..)
-                    | Message::FieldAppend(..)
-                    | Message::FieldValuePath(..)
                     | Message::FieldVariant(..)
                     | Message::FieldArray(..)
                     | Message::ElementKind(_)
@@ -904,7 +896,6 @@ impl App {
             self.connection = None;
         }
         if previous_layer != self.layer {
-            self.data_state = Default::default();
             self.explorer_index = crate::explorer::Index::new(self.project(), self.layer);
             self.explorer_focus = None;
             self.explorer_group = None;
@@ -1133,20 +1124,6 @@ impl App {
                     self.status = e;
                 }
             }
-            Message::FieldAppend(path, value) => {
-                if let Some(draft) = &mut self.draft
-                    && let Err(error) = draft.append(&path, value)
-                {
-                    self.status = error;
-                }
-            }
-            Message::FieldValuePath(path, key) => {
-                if let Some(draft) = &mut self.draft
-                    && let Err(error) = draft.value_path(&path, key)
-                {
-                    self.status = error;
-                }
-            }
             Message::FieldVariant(path, value) => {
                 if let Some(d) = &mut self.draft {
                     let result = d.materialize().and_then(|current| {
@@ -1316,57 +1293,12 @@ impl App {
                     }
                 }
             }
-            Message::StartSemanticReview(selected) => {
-                if self.apply() {
-                    match crate::semantic_review::State::new(self.project(), selected) {
-                        Ok(state) => {
-                            self.workflow =
-                                Some(crate::workflow::Workflow::Semantic(Box::new(state)))
-                        }
-                        Err(error) => self.status = error,
-                    }
-                }
-            }
             Message::Workflow(event) => {
                 if matches!(event, crate::workflow::Event::Cancel) {
                     self.workflow = None;
                     return Task::none();
                 }
                 if let Some(mut workflow) = self.workflow.take() {
-                    if let crate::workflow::Workflow::Semantic(state) = &mut workflow {
-                        match event {
-                            crate::workflow::Event::Semantic(event) => {
-                                state.update(self.project(), event)
-                            }
-                            crate::workflow::Event::Apply => {
-                                let focus = state.target(self.project());
-                                match state.command(self.project()) {
-                                    Ok(command) => {
-                                        if self.execute(command) {
-                                            if let Some(target) = focus {
-                                                self.selected = target;
-                                                if let Some(layer) = self.project().layer_of(target)
-                                                {
-                                                    self.layer = layer;
-                                                }
-                                                self.refresh_draft();
-                                            }
-                                            self.status = "Semantic review applied · model, source and baseline form one undoable change".into();
-                                            return Task::none();
-                                        }
-                                        state.error = Some(self.status.clone());
-                                    }
-                                    Err(error) => {
-                                        self.status = error.clone();
-                                        state.error = Some(error);
-                                    }
-                                }
-                            }
-                            _ => {}
-                        }
-                        self.workflow = Some(workflow);
-                        return Task::none();
-                    }
                     let stay_in_catalog = self.page == Page::Catalog
                         && matches!(&workflow, crate::workflow::Workflow::Ports(_));
                     let transition_focus = match &workflow {
@@ -1452,19 +1384,6 @@ impl App {
                     self.fit();
                 }
             }
-            Message::Data(event) => {
-                if self.data_state.update(&event) {
-                    return Task::none();
-                }
-                if self.apply() {
-                    match crate::data_view::command(self.project(), self.layer, event) {
-                        Ok(command) => {
-                            self.execute(command);
-                        }
-                        Err(error) => self.status = error,
-                    }
-                }
-            }
             Message::CreateKind(kind) => self.create_kind = kind,
             Message::Add(child) => {
                 if self.apply() {
@@ -3928,50 +3847,3 @@ mod lint_tests {
         assert!(app.project().elements.is_empty());
     }
 }
-
-#[cfg(test)]
-mod data_paging_lifecycle_tests {
-    use super::*;
-    #[test]
-    fn paging_preserves_same_context_and_resets_on_layer_or_document_replacement() {
-        let mut p = Project::empty();
-        let mut oa = None;
-        for layer in [Layer::Oa, Layer::Sa] {
-            for index in 0..70 {
-                let id = p
-                    .add_element(
-                        Kind::Interface,
-                        layer,
-                        &format!("Interface {layer} {index}"),
-                        None,
-                    )
-                    .unwrap();
-                if layer == Layer::Oa {
-                    oa = Some(id);
-                }
-            }
-        }
-        let mut app = App::with_project(p.clone());
-        let page = Message::Data(crate::data_view::Event::Page {
-            section: crate::data_view::Section::Catalog,
-            owner: None,
-            page: 2,
-        });
-        let _ = app.update(Message::Page(Page::Data));
-        let _ = app.update(page.clone());
-        let retained = app.data_state.clone();
-        let _ = app.update(Message::Page(Page::Catalog));
-        let _ = app.update(Message::Page(Page::Data));
-        let _ = app.update(Message::Layer(Layer::Oa));
-        assert_eq!(app.data_state, retained);
-        let _ = app.update(Message::Layer(Layer::Sa));
-        assert_eq!(app.data_state, crate::data_view::State::default());
-        let _ = app.update(page.clone());
-        let _ = app.update(Message::Select(oa.unwrap()));
-        assert_eq!(app.layer, Layer::Oa);
-        assert_eq!(app.data_state, crate::data_view::State::default());
-        let _ = app.update(page);
-        app.reset(p, None);
-        assert_eq!(app.data_state, crate::data_view::State::default());
-    }
-}

crates/oa-desktop/src/behavior/scenario.rs

@@ -78,17 +78,8 @@ pub enum Event {
     SecondGuard(String),
     Operator(Operator),
     Binding(Id, Choice),
-    Value(crate::data_values::FieldPathKey, String),
-    ValueFocus(crate::data_values::FieldPathKey),
-    ValueBrowse(Option<crate::data_values::FieldPathKey>),
-    ValuePage(ValueSection, usize),
+    Value(Id, String),
 }
-#[derive(Debug, Clone, Copy)]
-pub enum ValueSection {
-    Fields,
-    Authored,
-}
-const VALUE_PAGE_SIZE: usize = 24;
 #[derive(Default)]
 pub struct State {
     draft: Option<Draft>,
@@ -109,11 +100,7 @@ struct Draft {
     second_guard: String,
     operator: FragmentOperator,
     bindings: BTreeMap<Id, Id>,
-    values: BTreeMap<crate::data_values::FieldPathKey, String>,
-    value_focus: Option<crate::data_values::FieldPathKey>,
-    value_browse: Option<crate::data_values::FieldPathKey>,
-    value_browse_page: usize,
-    value_authored_page: usize,
+    values: BTreeMap<Id, String>,
 }
 impl State {
     pub(super) fn pending_owner(&self) -> Option<Id> {
@@ -159,10 +146,6 @@ impl State {
                     operator: FragmentOperator::Alternative,
                     bindings: BTreeMap::new(),
                     values: BTreeMap::new(),
-                    value_focus: None,
-                    value_browse: None,
-                    value_browse_page: 0,
-                    value_authored_page: 0,
                 });
             }
             Event::Cancel => self.acknowledge_commit(),
@@ -178,33 +161,21 @@ impl State {
                             d.bindings.clear();
                         }
                         Event::Exchange(c) => {
-                            if d.exchange != Some(c.id) {
-                                d.exchange = Some(c.id);
-                                d.reset_values();
-                                d.sender = None;
-                                d.receiver = None;
-                            }
+                            d.exchange = Some(c.id);
+                            d.values.clear();
+                            d.sender = None;
+                            d.receiver = None;
                         }
                         Event::Sender(c) => d.sender = Some(c.id),
                         Event::Receiver(c) => d.receiver = Some(c.id),
                         Event::Parent(c) => d.parent = c.id,
                         Event::Style(style) => {
-                            let previous = d.style;
                             d.style = style;
-                            if previous != style {
-                                if previous == MessageStyle::Timer || style == MessageStyle::Timer {
-                                    d.exchange = None;
-                                    d.sender = None;
-                                    d.receiver = None;
-                                    d.call = None;
-                                } else if (previous == MessageStyle::Reply)
-                                    != (style == MessageStyle::Reply)
-                                {
-                                    std::mem::swap(&mut d.sender, &mut d.receiver);
-                                    d.call = None;
-                                }
-                                d.retain_value_paths(p);
-                            }
+                            d.call = None;
+                            d.exchange = None;
+                            d.sender = None;
+                            d.receiver = None;
+                            d.values.clear();
                         }
                         Event::Call(c) => {
                             d.call = Some(c.id);
@@ -219,9 +190,6 @@ impl State {
                                 ..
                             }) = p.elements.get(&c.id).and_then(|e| e.shared())
                             {
-                                if d.exchange != *exchange {
-                                    d.reset_values();
-                                }
                                 d.exchange = *exchange;
                                 d.sender = *receiver;
                                 d.receiver = *sender;
@@ -234,29 +202,6 @@ impl State {
                         Event::Value(id, s) => {
                             d.values.insert(id, s);
                         }
-                        Event::ValueFocus(key)
-                            if d.exchange
-                                .and_then(|id| p.relations.get(&id))
-                                .and_then(|r| crate::data_values::resolve(p, r, &d.kind(), &key))
-                                .is_some() =>
-                        {
-                            d.value_focus = Some(key);
-                        }
-                        Event::ValueBrowse(key) => {
-                            if key.as_ref().is_none_or(|key| {
-                                d.exchange
-                                    .and_then(|id| p.relations.get(&id))
-                                    .and_then(|r| crate::data_values::resolve(p, r, &d.kind(), key))
-                                    .is_some()
-                            }) {
-                                d.value_browse = key;
-                                d.value_browse_page = 0;
-                            }
-                        }
-                        Event::ValuePage(section, page) => match section {
-                            ValueSection::Fields => d.value_browse_page = page,
-                            ValueSection::Authored => d.value_authored_page = page,
-                        },
                         _ => {}
                     }
                 }
@@ -377,7 +322,7 @@ fn exchanges(p: &Project, d: &Draft) -> Vec<Choice> {
                         exchange: Some(r.id),
                         sender: None,
                         receiver: None,
-                        message_kind: d.kind(),
+                        message_kind: MessageKind::Asynchronous,
                         reply_to: None,
                         values: vec![],
                     },
@@ -416,9 +361,6 @@ fn calls(p: &Project, d: &Draft) -> Vec<Choice> {
             let mut candidate = d.clone();
             candidate.style = MessageStyle::Reply;
             candidate.call = Some(e.id);
-            if candidate.exchange != *exchange {
-                candidate.reset_values();
-            }
             candidate.exchange = *exchange;
             candidate.sender = *receiver;
             candidate.receiver = *sender;
@@ -431,54 +373,6 @@ fn calls(p: &Project, d: &Draft) -> Vec<Choice> {
         .collect()
 }
 impl Draft {
-    fn reset_values(&mut self) {
-        self.values.clear();
-        self.value_focus = None;
-        self.value_browse = None;
-        self.value_browse_page = 0;
-        self.value_authored_page = 0;
-    }
-    fn retain_value_paths(&mut self, p: &Project) {
-        let kind = self.kind();
-        let exchange = self.exchange.and_then(|id| p.relations.get(&id));
-        self.values.retain(|key, _| {
-            exchange
-                .and_then(|r| crate::data_values::resolve(p, r, &kind, key))
-                .is_some()
-        });
-        if self.value_focus.as_ref().is_some_and(|key| {
-            exchange
-                .and_then(|r| crate::data_values::resolve(p, r, &kind, key))
-                .is_none()
-        }) {
-            self.value_focus = None;
-        }
-        if self.value_browse.as_ref().is_some_and(|key| {
-            exchange
-                .and_then(|r| crate::data_values::resolve(p, r, &kind, key))
-                .is_none()
-        }) {
-            self.value_browse = None;
-            self.value_browse_page = 0;
-        }
-    }
-    fn browsed_values(
-        &self,
-        p: &Project,
-        exchange: &Relation,
-    ) -> Result<Vec<crate::data_values::FieldPathChoice>, String> {
-        match &self.value_browse {
-            Some(key) => crate::data_values::children(p, exchange, &self.kind(), key),
-            None => Ok(crate::data_values::roots(p, exchange, &self.kind())),
-        }
-    }
-    fn authored_values(&self) -> Vec<(&crate::data_values::FieldPathKey, &str)> {
-        self.values
-            .iter()
-            .filter(|(_, value)| !value.trim().is_empty())
-            .map(|(key, value)| (key, value.as_str()))
-            .collect()
-    }
     fn kind(&self) -> MessageKind {
         match self.style {
             MessageStyle::Asynchronous => MessageKind::Asynchronous,
@@ -511,8 +405,7 @@ impl Draft {
                 .iter()
                 .filter(|(_, v)| !v.trim().is_empty())
                 .map(|(field, expression)| MessageValue {
-                    path: field.path.clone(),
-                    field: field.field,
+                    field: *field,
                     expression: expression.clone(),
                 })
                 .collect(),
@@ -717,144 +610,6 @@ impl Draft {
 fn event(e: Event) -> Message {
     Message::Behavior(super::Event::Scenario(e))
 }
-fn value_page(len: usize, requested: usize) -> std::ops::Range<usize> {
-    let start = requested.min(len.saturating_sub(1) / VALUE_PAGE_SIZE) * VALUE_PAGE_SIZE;
-    start..(start + VALUE_PAGE_SIZE).min(len)
-}
-fn value_pager(len: usize, requested: usize, section: ValueSection) -> Element<'static, Message> {
-    let range = value_page(len, requested);
-    let page = range.start / VALUE_PAGE_SIZE;
-    row![
-        button("Previous")
-            .on_press_maybe((page > 0).then(|| event(Event::ValuePage(section, page - 1)))),
-        text(format!(
-            "Page {} of {} · {} fields",
-            page + 1,
-            len.div_ceil(VALUE_PAGE_SIZE).max(1),
-            len
-        ))
-        .size(11),
-        button("Next")
-            .on_press_maybe((range.end < len).then(|| event(Event::ValuePage(section, page + 1))))
-    ]
-    .spacing(6)
-    .into()
-}
-fn value_panel<'a>(p: &Project, d: &'a Draft, exchange: &Relation) -> Element<'a, Message> {
-    use crate::data_values;
-    let mut out = column![text("Message values").size(14)].spacing(7);
-    if let Some(browse) = &d.value_browse {
-        let title = data_values::resolve(p, exchange, &d.kind(), browse)
-            .map(|choice| format!("Fields inside {}", choice.label))
-            .unwrap_or_else(|| "This record path is no longer available in this message.".into());
-        out = out.push(text(title).size(11)).push(
-            row![
-                button("Root fields").on_press(event(Event::ValueBrowse(None))),
-                button("Up one level")
-                    .on_press(event(Event::ValueBrowse(data_values::parent(browse))))
-            ]
-            .spacing(6),
-        );
-    } else {
-        out = out.push(text("Root fields · choose a record to browse its fields").size(11));
-    }
-    match d.browsed_values(p, exchange) {
-        Ok(choices) if !choices.is_empty() => {
-            let range = value_page(choices.len(), d.value_browse_page);
-            let visible = choices[range].to_vec();
-            let selected = visible
-                .iter()
-                .find(|choice| Some(&choice.key) == d.value_focus.as_ref())
-                .cloned();
-            out = out
-                .push(value_pager(
-                    choices.len(),
-                    d.value_browse_page,
-                    ValueSection::Fields,
-                ))
-                .push(
-                    pick_list(visible, selected, |choice| {
-                        event(Event::ValueFocus(choice.key))
-                    })
-                    .placeholder("Choose a field on this page…")
-                    .text_size(12)
-                    .padding(8)
-                    .width(Fill),
-                );
-        }
-        Ok(_) => {
-            out = out.push(text("No fields at this level for this message phase.").size(11));
-        }
-        Err(error) => out = out.push(text(error).size(11).color(style::MUTED)),
-    }
-    match d
-        .value_focus
-        .as_ref()
-        .map(|key| data_values::resolve(p, exchange, &d.kind(), key))
-    {
-        Some(Some(focus)) => {
-            let key = focus.key;
-            out = out
-                .push(text(focus.label).size(12))
-                .push(
-                    text_input(
-                        "Optional value expression",
-                        d.values.get(&key).map(String::as_str).unwrap_or(""),
-                    )
-                    .on_input({
-                        let key = key.clone();
-                        move |value| event(Event::Value(key.clone(), value))
-                    })
-                    .padding(8)
-                    .size(12),
-                )
-                .push(text("An empty expression omits this value.").size(11));
-            let mut actions = row![
-                button("Show enclosing fields")
-                    .on_press(event(Event::ValueBrowse(data_values::parent(&key))))
-            ]
-            .spacing(6);
-            if matches!(p.elements.get(&key.field).and_then(oa_core::Element::shared),
-                Some(SharedBody::DataField { type_ref: TypeRef::Named(record),
-                    storage: FieldStorage::Value, .. }) if data::is_record(p, *record))
-            {
-                actions = actions.push(
-                    button("Browse record fields").on_press(event(Event::ValueBrowse(Some(key)))),
-                );
-            }
-            out = out.push(actions);
-        }
-        Some(None) => {
-            out = out.push(text("The selected path is unavailable in this message. Choose a compatible field; entered values remain in the draft.")
-                .size(11).color(style::MUTED));
-        }
-        None => out = out.push(text("Choose a field to enter its value expression.").size(11)),
-    }
-    let authored = d.authored_values();
-    out = out.push(text(format!("Authored values ({})", authored.len())).size(12));
-    if authored.is_empty() {
-        out = out.push(text("No value expressions entered.").size(11));
-    } else {
-        out = out.push(value_pager(
-            authored.len(),
-            d.value_authored_page,
-            ValueSection::Authored,
-        ));
-        for (key, expression) in &authored[value_page(authored.len(), d.value_authored_page)] {
-            let title = data_values::resolve(p, exchange, &d.kind(), key)
-                .map(|choice| choice.label)
-                .unwrap_or_else(|| format!("Unavailable field {} · review this value", key.field));
-            out = out.push(
-                button(
-                    column![text(title).size(11), text(short(expression, 100)).size(11)].spacing(3),
-                )
-                .on_press(event(Event::ValueFocus((*key).clone())))
-                .width(Fill),
-            );
-        }
-    }
-    out.into()
-}
 fn picker<'a>(
     choices: Vec<Choice>,
     selected: Option<Id>,
@@ -1007,7 +762,21 @@ pub fn view<'a>(app: &'a App, owner: Id, mut out: Column<'a, Message>) -> Elemen
                 );
             }
             if let Some(exchange) = d.exchange.and_then(|id| p.relations.get(&id)) {
-                form = form.push(value_panel(p, d, exchange));
+                for field in validation::carried_fields(p, exchange) {
+                    form = form.push(
+                        row![
+                            label(p.named(field)),
+                            text_input(
+                                "Optional value expression",
+                                d.values.get(&field).map(String::as_str).unwrap_or("")
+                            )
+                            .on_input(move |s| event(Event::Value(field, s)))
+                            .padding(8)
+                            .size(12)
+                        ]
+                        .spacing(7),
+                    );
+                }
             }
             if d.style == MessageStyle::CallReply {
                 form=form.push(label("Creates the call and reversed, correlated reply together in one undoable operation."));
@@ -1420,563 +1189,3 @@ mod tests {
         );
     }
 }
-
-#[cfg(test)]
-mod data_contract_tests {
-    use super::*;
-
-    #[test]
-    fn scenario_form_commits_two_reused_record_values_and_correlated_reply_atomically() {
-        let mut f = crate::data_values::tests::payload();
-        if let Some(SharedBody::DataField { direction, .. }) = f
-            .project
-            .elements
-            .get_mut(&f.destination)
-            .unwrap()
-            .shared_mut()
-        {
-            *direction = ParameterDirection::InOut;
-        }
-        let source = f.project.relations[&f.exchange].source();
-        let target = f.project.relations[&f.exchange].target();
-        let mut lines = vec![];
-        for (name, represented) in [("Requester", source), ("Performer", target)] {
-            let id = f
-                .project
-                .add_element(Kind::Lifeline, Layer::Oa, name, Some(f.scenario))
-                .unwrap();
-            *f.project
-                .elements
-                .get_mut(&id)
-                .unwrap()
-                .shared_mut()
-                .unwrap() = SharedBody::Lifeline {
-                represented: Some(represented),
-            };
-            lines.push(id);
-        }
-        let mut state = State::default();
-        for event in [
-            Event::Start(f.scenario, Tool::Message),
-            Event::Name("Move coordinates".into()),
-            Event::Exchange(named_choice(&f.project, f.exchange)),
-            Event::Sender(named_choice(&f.project, lines[0])),
-            Event::Receiver(named_choice(&f.project, lines[1])),
-        ] {
-            state.update(&f.project, event).unwrap();
-        }
-        assert!(
-            exchanges(&f.project, state.draft.as_ref().unwrap())
-                .iter()
-                .any(|c| c.id == f.exchange)
-        );
-        for (parameter, expression) in [(f.origin, "45.0"), (f.destination, "46.0")] {
-            state
-                .update(
-                    &f.project,
-                    Event::Value(
-                        crate::data_values::FieldPathKey {
-                            path: vec![parameter],
-                            field: f.leaf,
-                        },
-                        expression.into(),
-                    ),
-                )
-                .unwrap();
-        }
-        let before = state.draft.as_ref().unwrap().values.clone();
-        state
-            .update(&f.project, Event::Style(MessageStyle::Call))
-            .unwrap();
-        state
-            .update(
-                &f.project,
-                Event::Exchange(named_choice(&f.project, f.exchange)),
-            )
-            .unwrap();
-        assert_eq!(state.draft.as_ref().unwrap().values, before);
-        assert_eq!(state.draft.as_ref().unwrap().sender, Some(lines[0]));
-        assert_eq!(state.draft.as_ref().unwrap().receiver, Some(lines[1]));
-        state
-            .update(&f.project, Event::Style(MessageStyle::CallReply))
-            .unwrap();
-        assert_eq!(state.draft.as_ref().unwrap().values, before);
-        let command = state.prepare_pending(&f.project).unwrap();
-        let mut document =
-            crate::document::Document::from_project(f.project.clone(), Default::default()).unwrap();
-        document.execute(command).unwrap();
-        let messages = document
-            .project()
-            .children(f.scenario)
-            .filter_map(|e| match e.shared()? {
-                SharedBody::Occurrence {
-                    body:
-                        OccurrenceBody::Exchange {
-                            message_kind,
-                            values,
-                            ..
-                        },
-                    ..
-                } => Some((message_kind, values)),
-                _ => None,
-            })
-            .collect::<Vec<_>>();
-        let call = messages
-            .iter()
-            .find(|(kind, _)| **kind == MessageKind::Call)
-            .unwrap()
-            .1;
-        assert_eq!(call.len(), 2);
-        assert_eq!(
-            call.iter().map(|v| v.field).collect::<BTreeSet<_>>(),
-            BTreeSet::from([f.leaf])
-        );
-        assert_eq!(
-            call.iter().map(|v| v.path.clone()).collect::<BTreeSet<_>>(),
-            BTreeSet::from([vec![f.origin], vec![f.destination]])
-        );
-        assert!(
-            messages
-                .iter()
-                .find(|(kind, _)| **kind == MessageKind::Reply)
-                .unwrap()
-                .1
-                .is_empty()
-        );
-        assert!(document.undo());
-        assert_eq!(document.project(), &f.project);
-        assert!(!document.undo());
-    }
-    #[test]
-    fn recursive_value_focus_exposes_authored_leaf_and_phase_changes_retain_surviving_keys() {
-        let (f, next) = crate::data_values::tests::recursive_payload();
-        let mut state = State::default();
-        state
-            .update(&f.project, Event::Start(f.scenario, Tool::Message))
-            .unwrap();
-        state
-            .update(
-                &f.project,
-                Event::Exchange(named_choice(&f.project, f.exchange)),
-            )
-            .unwrap();
-        let key = crate::data_values::FieldPathKey {
-            path: vec![f.origin, next],
-            field: f.leaf,
-        };
-        state
-            .update(
-                &f.project,
-                Event::ValueBrowse(crate::data_values::parent(&key)),
-            )
-            .unwrap();
-        state
-            .update(&f.project, Event::ValueFocus(key.clone()))
-            .unwrap();
-        assert!(
-            state
-                .draft
-                .as_ref()
-                .unwrap()
-                .browsed_values(&f.project, &f.project.relations[&f.exchange])
-                .unwrap()
-                .iter()
-                .any(|c| c.key == key)
-        );
-        state
-            .update(
-                &f.project,
-                Event::Value(key.clone(), "recursive expression".into()),
-            )
-            .unwrap();
-        state
-            .update(&f.project, Event::Style(MessageStyle::Call))
-            .unwrap();
-        assert_eq!(
-            state.draft.as_ref().unwrap().values[&key],
-            "recursive expression"
-        );
-        state
-            .update(&f.project, Event::Style(MessageStyle::Asynchronous))
-            .unwrap();
-        assert_eq!(
-            state.draft.as_ref().unwrap().values[&key],
-            "recursive expression"
-        );
-        state
-            .update(&f.project, Event::Style(MessageStyle::Reply))
-            .unwrap();
-        assert!(
-            state.draft.as_ref().unwrap().values.is_empty(),
-            "In parameters do not become reply values"
-        );
-        let out = crate::data_values::FieldPathKey {
-            path: vec![f.destination],
-            field: f.leaf,
-        };
-        state
-            .update(&f.project, Event::Value(out.clone(), "reply value".into()))
-            .unwrap();
-        state
-            .update(&f.project, Event::Style(MessageStyle::Asynchronous))
-            .unwrap();
-        assert_eq!(state.draft.as_ref().unwrap().values[&out], "reply value");
-    }
-
-    fn panel_counts(p: &Project, d: &Draft, exchange: Id) -> (usize, usize) {
-        let input: Element<'_, Message> = text_input("", "").into();
-        let input_tag = iced::advanced::widget::Tree::new(input.as_widget()).tag;
-        let panel = value_panel(p, d, &p.relations[&exchange]);
-        let tree = iced::advanced::widget::Tree::new(panel.as_widget());
-        fn count(
-            tree: &iced::advanced::widget::Tree,
-            tag: iced::advanced::widget::tree::Tag,
-        ) -> (usize, usize) {
-            tree.children.iter().fold(
-                (1, usize::from(tree.tag == tag)),
-                |(nodes, inputs), child| {
-                    let (child_nodes, child_inputs) = count(child, tag);
-                    (nodes + child_nodes, inputs + child_inputs)
-                },
-            )
-        }
-        count(&tree, input_tag)
-    }
-
-    #[test]
-    fn large_payload_has_one_editor_with_reachable_field_and_authored_pages() {
-        let f = crate::data_values::tests::wide_payload();
-        let p = &f.project;
-        let exchange = &p.relations[&f.exchange];
-        let mut state = State::default();
-        state
-            .update(p, Event::Start(f.scenario, Tool::Message))
-            .unwrap();
-        state
-            .update(p, Event::Exchange(named_choice(p, f.exchange)))
-            .unwrap();
-        let roots = crate::data_values::roots(p, exchange, &MessageKind::Call);
-        assert_eq!(roots.len(), 96);
-        assert_eq!(
-            panel_counts(p, state.draft.as_ref().unwrap(), f.exchange).1,
-            0
-        );
-        let mut visited = BTreeSet::new();
-        for page in 0..roots.len().div_ceil(VALUE_PAGE_SIZE) {
-            state
-                .update(p, Event::ValuePage(ValueSection::Fields, page))
-                .unwrap();
-            let d = state.draft.as_ref().unwrap();
-            let choices = d.browsed_values(p, exchange).unwrap();
-            let visible = choices[value_page(choices.len(), d.value_browse_page)].to_vec();
-            assert!(visible.len() <= VALUE_PAGE_SIZE);
-            for choice in visible {
-                visited.insert(choice.key.clone());
-                state
-                    .update(p, Event::ValueFocus(choice.key.clone()))
-                    .unwrap();
-                state
-                    .update(p, Event::Value(choice.key, format!("draft {page}")))
-                    .unwrap();
-            }
-            let (nodes, inputs) = panel_counts(p, state.draft.as_ref().unwrap(), f.exchange);
-            assert_eq!(
-                inputs, 1,
-                "one input for over twelve thousand carried paths"
-            );
-            assert!(nodes < 200, "{nodes} widgets for the bounded value panel");
-        }
-        assert_eq!(
-            visited,
-            roots.iter().map(|choice| choice.key.clone()).collect()
-        );
-
-        state
-            .update(p, Event::ValueBrowse(Some(roots[0].key.clone())))
-            .unwrap();
-        assert_eq!(state.draft.as_ref().unwrap().value_browse_page, 0);
-        let children = state
-            .draft
-            .as_ref()
-            .unwrap()
-            .browsed_values(p, exchange)
-            .unwrap();
-        assert_eq!(children.len(), 128);
-        let mut visited_children = BTreeSet::new();
-        for page in 0..children.len().div_ceil(VALUE_PAGE_SIZE) {
-            state
-                .update(p, Event::ValuePage(ValueSection::Fields, page))
-                .unwrap();
-            let d = state.draft.as_ref().unwrap();
-            let choices = d.browsed_values(p, exchange).unwrap();
-            for choice in &choices[value_page(choices.len(), d.value_browse_page)] {
-                assert_eq!(choice.key.path, [roots[0].key.field]);
-                visited_children.insert(choice.key.clone());
-            }
-        }
-        assert_eq!(
-            visited_children,
-            children.iter().map(|choice| choice.key.clone()).collect()
-        );
-
-        let nested = children[0].key.clone();
-        state.update(p, Event::ValueFocus(nested.clone())).unwrap();
-        state
-            .update(p, Event::Value(nested.clone(), "unfinished(\"".into()))
-            .unwrap();
-        let before = state.draft.as_ref().unwrap().values.clone();
-        let before_browse = state.draft.as_ref().unwrap().value_browse.clone();
-        let before_page = state.draft.as_ref().unwrap().value_browse_page;
-        for event in [
-            Event::Style(MessageStyle::Call),
-            Event::Exchange(named_choice(p, f.exchange)),
-            Event::Style(MessageStyle::CallReply),
-        ] {
-            state.update(p, event).unwrap();
-        }
-        let d = state.draft.as_ref().unwrap();
-        assert_eq!(d.values, before);
-        assert_eq!(d.value_browse, before_browse);
-        assert_eq!(d.value_browse_page, before_page);
-        assert_eq!(d.value_focus, Some(nested));
-
-        let mut authored = BTreeSet::new();
-        for page in 0..before.len().div_ceil(VALUE_PAGE_SIZE) {
-            state
-                .update(p, Event::ValuePage(ValueSection::Authored, page))
-                .unwrap();
-            let d = state.draft.as_ref().unwrap();
-            let values = d.authored_values();
-            for (key, _) in &values[value_page(values.len(), d.value_authored_page)] {
-                authored.insert((*key).clone());
-            }
-            let (nodes, inputs) = panel_counts(p, d, f.exchange);
-            assert_eq!(inputs, 1);
-            assert!(nodes < 200, "{nodes} widget nodes");
-        }
-        assert_eq!(authored, before.keys().cloned().collect());
-        state.update(p, Event::ValueBrowse(None)).unwrap();
-        state
-            .update(p, Event::ValuePage(ValueSection::Fields, usize::MAX))
-            .unwrap();
-        let d = state.draft.as_ref().unwrap();
-        assert_eq!(
-            d.values, before,
-            "browsing and page clamping never remove drafts"
-        );
-        let OccurrenceBody::Exchange { values, .. } = d.message_body() else {
-            panic!()
-        };
-        assert_eq!(
-            values.len(),
-            before.len(),
-            "commit includes every authored page"
-        );
-        assert_eq!(panel_counts(p, d, f.exchange).1, 1);
-    }
-
-    #[test]
-    fn recursive_browsing_up_and_root_keep_values_and_report_the_depth_limit() {
-        let (f, next) = crate::data_values::tests::recursive_payload();
-        let p = &f.project;
-        let exchange = &p.relations[&f.exchange];
-        let mut state = State::default();
-        state
-            .update(p, Event::Start(f.scenario, Tool::Message))
-            .unwrap();
-        state
-            .update(p, Event::Exchange(named_choice(p, f.exchange)))
-            .unwrap();
-        let root = crate::data_values::FieldPathKey {
-            path: vec![],
-            field: f.origin,
-        };
-        state.update(p, Event::ValueFocus(root.clone())).unwrap();
-        state
-            .update(p, Event::ValueBrowse(Some(root.clone())))
-            .unwrap();
-        let inner = state
-            .draft
-            .as_ref()
-            .unwrap()
-            .browsed_values(p, exchange)
-            .unwrap()
-            .into_iter()
-            .find(|choice| choice.key.field == next)
-            .unwrap()
-            .key;
-        state.update(p, Event::ValueFocus(inner.clone())).unwrap();
-        state
-            .update(p, Event::ValueBrowse(Some(inner.clone())))
-            .unwrap();
-        let leaf = state
-            .draft
-            .as_ref()
-            .unwrap()
-            .browsed_values(p, exchange)
-            .unwrap()
-            .into_iter()
-            .find(|choice| choice.key.field == f.leaf)
-            .unwrap()
-            .key;
-        assert_eq!(leaf.path, [f.origin, next]);
-        state.update(p, Event::ValueFocus(leaf.clone())).unwrap();
-        state
-            .update(p, Event::Value(leaf.clone(), "keep this draft".into()))
-            .unwrap();
-        state
-            .update(p, Event::ValueBrowse(crate::data_values::parent(&inner)))
-            .unwrap();
-        assert_eq!(state.draft.as_ref().unwrap().value_browse, Some(root));
-        state.update(p, Event::ValueBrowse(None)).unwrap();
-        assert_eq!(
-            state.draft.as_ref().unwrap().values[&leaf],
-            "keep this draft"
-        );
-        assert_eq!(
-            panel_counts(p, state.draft.as_ref().unwrap(), f.exchange).1,
-            1
-        );
-        let deepest = crate::data_values::FieldPathKey {
-            path: std::iter::once(f.origin)
-                .chain(std::iter::repeat_n(next, data::MAX_VALUE_PATH_DEPTH - 1))
-                .collect(),
-            field: next,
-        };
-        state.update(p, Event::ValueBrowse(Some(deepest))).unwrap();
-        assert!(
-            state
-                .draft
-                .as_ref()
-                .unwrap()
-                .browsed_values(p, exchange)
-                .unwrap_err()
-                .contains("128")
-        );
-        assert_eq!(
-            panel_counts(p, state.draft.as_ref().unwrap(), f.exchange).1,
-            1
-        );
-        assert_eq!(
-            state.draft.as_ref().unwrap().values[&leaf],
-            "keep this draft"
-        );
-        state
-            .update(p, Event::Value(leaf.clone(), String::new()))
-            .unwrap();
-        let d = state.draft.as_ref().unwrap();
-        assert!(d.authored_values().is_empty());
-        assert_eq!(d.values[&leaf], "", "empty input remains an editable draft");
-    }
-
-    #[test]
-    fn reply_call_picker_previews_the_same_value_reset_as_selecting_another_exchange() {
-        let mut f = crate::data_values::tests::payload();
-        let p = &mut f.project;
-        let source = p.relations[&f.exchange].source();
-        let target = p.relations[&f.exchange].target();
-        let mut lifelines = vec![];
-        for (name, represented) in [("Caller", source), ("Callee", target)] {
-            let id = p
-                .add_element(Kind::Lifeline, Layer::Oa, name, Some(f.scenario))
-                .unwrap();
-            *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::Lifeline {
-                represented: Some(represented),
-            };
-            lifelines.push(id);
-        }
-        let other_item = p
-            .add_element(Kind::ExchangeItem, Layer::Oa, "Other operation", None)
-            .unwrap();
-        *p.elements
-            .get_mut(&other_item)
-            .unwrap()
-            .shared_mut()
-            .unwrap() = p.elements[&f.item].shared().unwrap().clone();
-        let other_field = p
-            .add_element(Kind::DataField, Layer::Oa, "Result", Some(other_item))
-            .unwrap();
-        *p.elements
-            .get_mut(&other_field)
-            .unwrap()
-            .shared_mut()
-            .unwrap() = SharedBody::DataField {
-            type_ref: TypeRef::Real,
-            direction: ParameterDirection::Out,
-            minimum: 1,
-            maximum: Some(1),
-            unit: String::new(),
-            storage: FieldStorage::Value,
-            default: None,
-        };
-        let other_exchange = p.relate(RelationKind::Interaction, "Other exchange", source, target);
-        p.relations.get_mut(&other_exchange).unwrap().body = RelationBody::Interaction {
-            source,
-            target,
-            items: vec![other_item],
-        };
-        let mut call_ids = vec![];
-        for (name, exchange) in [("First call", f.exchange), ("Other call", other_exchange)] {
-            let call = occurrence(
-                p,
-                f.scenario,
-                name,
-                OccurrenceBody::Exchange {
-                    exchange: Some(exchange),
-                    sender: Some(lifelines[0]),
-                    receiver: Some(lifelines[1]),
-                    message_kind: MessageKind::Call,
-                    reply_to: None,
-                    values: vec![],
-                },
-            );
-            call_ids.push(call.id);
-            *p = execute_batch(p, &[Command::CreateElement(call)]).unwrap();
-        }
-        let mut state = State::default();
-        state
-            .update(p, Event::Start(f.scenario, Tool::Message))
-            .unwrap();
-        state.update(p, Event::Style(MessageStyle::Reply)).unwrap();
-        state
-            .update(p, Event::Call(named_choice(p, call_ids[0])))
-            .unwrap();
-        let key = crate::data_values::FieldPathKey {
-            path: vec![f.destination],
-            field: f.leaf,
-        };
-        state.update(p, Event::ValueFocus(key.clone())).unwrap();
-        state
-            .update(p, Event::Value(key.clone(), "reply expression".into()))
-            .unwrap();
-        state
-            .update(p, Event::ValueBrowse(crate::data_values::parent(&key)))
-            .unwrap();
-        let offered = calls(p, state.draft.as_ref().unwrap());
-        assert!(
-            offered.iter().any(|choice| choice.id == call_ids[1]),
-            "a different exchange remains selectable after entering a value"
-        );
-        assert_eq!(
-            state.draft.as_ref().unwrap().values[&key],
-            "reply expression",
-            "preview is read-only"
-        );
-        state
-            .update(p, Event::Call(named_choice(p, call_ids[0])))
-            .unwrap();
-        assert_eq!(
-            state.draft.as_ref().unwrap().values[&key],
-            "reply expression"
-        );
-        state
-            .update(p, Event::Call(named_choice(p, call_ids[1])))
-            .unwrap();
-        let d = state.draft.as_ref().unwrap();
-        assert!(d.values.is_empty());
-        assert!(d.value_focus.is_none());
-        assert!(d.value_browse.is_none());
-        assert_eq!(d.exchange, Some(other_exchange));
-        assert!(state.prepare_pending(p).is_ok());
-    }
-}

crates/oa-desktop/src/connection_tool.rs

@@ -432,12 +432,11 @@ mod tests {
         let provided = element(&mut p, Kind::Interface, Layer::Sa, "Reporting");
         let required = element(&mut p, Kind::Interface, Layer::Sa, "Results");
         for (interface, item) in [(provided, report), (required, result)] {
-            p.relate(
-                RelationKind::InterfaceItemAllocation,
-                "Allocated item",
-                interface,
-                item,
-            );
+            *p.elements
+                .get_mut(&interface)
+                .unwrap()
+                .shared_mut()
+                .unwrap() = SharedBody::Interface { items: vec![item] };
         }
         p.relate(
             RelationKind::InterfaceProvision,

crates/oa-desktop/src/data_values.rs

@@ -1,485 +0,0 @@
-//! One address for a carried value, shared by scenario creation and property editing.
-use oa_core::*;
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct FieldPathKey {
-    pub path: Vec<Id>,
-    pub field: Id,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct FieldPathChoice {
-    pub key: FieldPathKey,
-    pub label: String,
-}
-impl std::fmt::Display for FieldPathChoice {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&self.label)
-    }
-}
-
-fn phase_allows(project: &Project, entry: &data::CarriedFieldPath, phase: &MessageKind) -> bool {
-    data::item_mechanism(project, entry.item) != Some(ExchangeMechanism::Operation)
-        || match phase {
-            MessageKind::Call => matches!(
-                entry.direction,
-                ParameterDirection::Unspecified
-                    | ParameterDirection::In
-                    | ParameterDirection::InOut
-            ),
-            MessageKind::Reply => matches!(
-                entry.direction,
-                ParameterDirection::Unspecified
-                    | ParameterDirection::Out
-                    | ParameterDirection::InOut
-                    | ParameterDirection::Return
-            ),
-            _ => true,
-        }
-}
-fn named_choice(project: &Project, entry: data::CarriedFieldPath) -> FieldPathChoice {
-    let qualified = entry
-        .path
-        .iter()
-        .chain(std::iter::once(&entry.field))
-        .map(|id| {
-            project
-                .elements
-                .get(id)
-                .map(|e| format!("{} (@{})", e.name, e.alias))
-                .unwrap_or_else(|| id.to_string())
-        })
-        .collect::<Vec<_>>()
-        .join(" → ");
-    let direction =
-        if data::item_mechanism(project, entry.item) == Some(ExchangeMechanism::Operation) {
-            match entry.direction {
-                ParameterDirection::Unspecified => " · direction unspecified — review",
-                ParameterDirection::In => " · In",
-                ParameterDirection::Out => " · Out",
-                ParameterDirection::InOut => " · InOut",
-                ParameterDirection::Return => " · Return",
-            }
-        } else {
-            ""
-        };
-    FieldPathChoice {
-        key: FieldPathKey {
-            path: entry.path,
-            field: entry.field,
-        },
-        label: format!("{} / {qualified}{direction}", project.named(entry.item)),
-    }
-}
-
-pub fn choices(
-    project: &Project,
-    exchange: &Relation,
-    phase: &MessageKind,
-) -> Result<Vec<FieldPathChoice>, String> {
-    Ok(data::try_carried_field_paths(project, exchange)?
-        .into_iter()
-        .filter(|entry| phase_allows(project, entry, phase))
-        .map(|entry| named_choice(project, entry))
-        .collect())
-}
-
-/// Direct carried fields only: an unrelated deep branch must not prevent
-/// browsing a root field. Preserve the core resolver's first carried owner.
-pub fn roots(project: &Project, exchange: &Relation, phase: &MessageKind) -> Vec<FieldPathChoice> {
-    let mut seen = std::collections::BTreeSet::new();
-    exchange
-        .body
-        .items()
-        .iter()
-        .flat_map(|item| {
-            data::effective_fields(project, *item)
-                .into_iter()
-                .filter_map(|field| {
-                    let SharedBody::DataField { direction, .. } = field.shared()? else {
-                        return None;
-                    };
-                    Some(data::CarriedFieldPath {
-                        item: *item,
-                        path: vec![],
-                        field: field.id,
-                        direction: *direction,
-                    })
-                })
-        })
-        .filter(|entry| seen.insert(entry.field))
-        .filter(|entry| phase_allows(project, entry, phase))
-        .map(|entry| named_choice(project, entry))
-        .collect()
-}
-
-/// Resolve authored finite paths as well as the finite representative picker list.
-/// In particular, optional recursive Value records may be traversed repeatedly.
-pub fn resolve(
-    project: &Project,
-    exchange: &Relation,
-    phase: &MessageKind,
-    key: &FieldPathKey,
-) -> Option<FieldPathChoice> {
-    data::carried_value_path(project, exchange, &key.path, key.field)
-        .filter(|entry| phase_allows(project, entry, phase))
-        .map(|entry| named_choice(project, entry))
-}
-
-pub fn parent(key: &FieldPathKey) -> Option<FieldPathKey> {
-    let (&field, path) = key.path.split_last()?;
-    Some(FieldPathKey {
-        path: path.to_vec(),
-        field,
-    })
-}
-
-/// Expand exactly one selected record. This keeps recursive authoring explicit
-/// and finite, and never traverses Reference storage or manufactures value paths.
-pub fn children(
-    project: &Project,
-    exchange: &Relation,
-    phase: &MessageKind,
-    key: &FieldPathKey,
-) -> Result<Vec<FieldPathChoice>, String> {
-    let Some(entry) = data::carried_value_path(project, exchange, &key.path, key.field)
-        .filter(|entry| phase_allows(project, entry, phase))
-    else {
-        return Ok(vec![]);
-    };
-    let Some(SharedBody::DataField {
-        type_ref: TypeRef::Named(record),
-        storage: FieldStorage::Value,
-        ..
-    }) = project.elements.get(&key.field).and_then(Element::shared)
-    else {
-        return Ok(vec![]);
-    };
-    if !data::is_record(project, *record) {
-        return Ok(vec![]);
-    }
-    if key.path.len() >= data::MAX_VALUE_PATH_DEPTH {
-        return Err(format!(
-            "A value path can contain at most {} enclosing fields.",
-            data::MAX_VALUE_PATH_DEPTH
-        ));
-    }
-    let mut path = key.path.clone();
-    path.push(key.field);
-    Ok(data::effective_fields(project, *record)
-        .into_iter()
-        .map(|field| {
-            named_choice(
-                project,
-                data::CarriedFieldPath {
-                    item: entry.item,
-                    path: path.clone(),
-                    field: field.id,
-                    direction: entry.direction,
-                },
-            )
-        })
-        .collect())
-}
-
-#[cfg(test)]
-pub(crate) mod tests {
-    use super::*;
-
-    pub struct Payload {
-        pub project: Project,
-        pub exchange: Id,
-        pub item: Id,
-        pub leaf: Id,
-        pub origin: Id,
-        pub destination: Id,
-        pub scenario: Id,
-    }
-    pub fn payload() -> Payload {
-        let mut p = Project::empty();
-        let item = p
-            .add_element(Kind::ExchangeItem, Layer::Oa, "Move", None)
-            .unwrap();
-        *p.elements.get_mut(&item).unwrap().shared_mut().unwrap() = SharedBody::ExchangeItem {
-            kind: ExchangeItemKind::Information,
-            mechanism: ExchangeMechanism::Operation,
-            supertype: None,
-        };
-        let record = p
-            .add_element(Kind::DataType, Layer::Oa, "Coordinate", None)
-            .unwrap();
-        *p.elements.get_mut(&record).unwrap().shared_mut().unwrap() = SharedBody::DataType {
-            definition: DataTypeDefinition::Record { supertype: None },
-            default: None,
-            unit: String::new(),
-        };
-        let leaf = p
-            .add_element(Kind::DataField, Layer::Oa, "latitude", Some(record))
-            .unwrap();
-        let origin = p
-            .add_element(Kind::DataField, Layer::Oa, "origin", Some(item))
-            .unwrap();
-        let destination = p
-            .add_element(Kind::DataField, Layer::Oa, "destination", Some(item))
-            .unwrap();
-        for (id, type_ref, direction) in [
-            (leaf, TypeRef::Real, ParameterDirection::Unspecified),
-            (origin, TypeRef::Named(record), ParameterDirection::In),
-            (destination, TypeRef::Named(record), ParameterDirection::Out),
-        ] {
-            *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::DataField {
-                type_ref,
-                direction,
-                minimum: 1,
-                maximum: Some(1),
-                unit: String::new(),
-                storage: FieldStorage::Value,
-                default: None,
-            };
-        }
-        let source = p
-            .add_element(Kind::Activity, Layer::Oa, "Request", None)
-            .unwrap();
-        let target = p
-            .add_element(Kind::Activity, Layer::Oa, "Perform", None)
-            .unwrap();
-        let exchange = p.relate(RelationKind::Interaction, "Movement", source, target);
-        p.relations.get_mut(&exchange).unwrap().body = RelationBody::Interaction {
-            source,
-            target,
-            items: vec![item],
-        };
-        let scenario = p
-            .add_element(Kind::Scenario, Layer::Oa, "Conversation", None)
-            .unwrap();
-        validate_candidate(&p).unwrap();
-        Payload {
-            project: p,
-            exchange,
-            item,
-            leaf,
-            origin,
-            destination,
-            scenario,
-        }
-    }
-
-    #[test]
-    fn phase_choices_keep_reused_record_addresses_distinct() {
-        let mut f = payload();
-        assert_eq!(
-            data::item_mechanism(&f.project, f.item),
-            Some(ExchangeMechanism::Operation)
-        );
-        let call = choices(
-            &f.project,
-            &f.project.relations[&f.exchange],
-            &MessageKind::Call,
-        )
-        .unwrap();
-        assert!(
-            call.iter()
-                .any(|c| c.key.path == [f.origin] && c.key.field == f.leaf)
-        );
-        assert!(!call.iter().any(|c| c.key.path == [f.destination]));
-        let reply = choices(
-            &f.project,
-            &f.project.relations[&f.exchange],
-            &MessageKind::Reply,
-        )
-        .unwrap();
-        assert!(
-            reply
-                .iter()
-                .any(|c| c.key.path == [f.destination] && c.key.field == f.leaf)
-        );
-        assert!(!reply.iter().any(|c| c.key.path == [f.origin]));
-        if let Some(SharedBody::DataField { direction, .. }) = f
-            .project
-            .elements
-            .get_mut(&f.destination)
-            .unwrap()
-            .shared_mut()
-        {
-            *direction = ParameterDirection::InOut;
-        }
-        let both = choices(
-            &f.project,
-            &f.project.relations[&f.exchange],
-            &MessageKind::Call,
-        )
-        .unwrap();
-        let leaves = both
-            .iter()
-            .filter(|c| c.key.field == f.leaf)
-            .collect::<Vec<_>>();
-        assert_eq!(leaves.len(), 2);
-        assert_ne!(leaves[0].key, leaves[1].key);
-        assert_ne!(leaves[0].label, leaves[1].label);
-        let values = leaves
-            .into_iter()
-            .map(|c| (c.key.clone(), "1".to_string()))
-            .collect::<std::collections::BTreeMap<_, _>>();
-        assert_eq!(values.len(), 2);
-    }
-
-    #[test]
-    fn reference_parameter_stops_descent_and_unspecified_direction_remains_visible() {
-        let mut f = payload();
-        if let Some(SharedBody::DataField {
-            storage, direction, ..
-        }) = f.project.elements.get_mut(&f.origin).unwrap().shared_mut()
-        {
-            *storage = FieldStorage::Reference;
-            *direction = ParameterDirection::Unspecified;
-        }
-        let call = choices(
-            &f.project,
-            &f.project.relations[&f.exchange],
-            &MessageKind::Call,
-        )
-        .unwrap();
-        let direct = call.iter().find(|c| c.key.field == f.origin).unwrap();
-        assert!(direct.key.path.is_empty());
-        assert!(direct.label.contains("unspecified"));
-        assert!(!call.iter().any(|c| c.key.path.contains(&f.origin)));
-    }
-    pub fn recursive_payload() -> (Payload, Id) {
-        let mut f = payload();
-        let record = f.project.elements[&f.leaf].parent.unwrap();
-        let next = f
-            .project
-            .add_element(Kind::DataField, Layer::Oa, "next", Some(record))
-            .unwrap();
-        *f.project
-            .elements
-            .get_mut(&next)
-            .unwrap()
-            .shared_mut()
-            .unwrap() = SharedBody::DataField {
-            type_ref: TypeRef::Named(record),
-            minimum: 0,
-            maximum: Some(1),
-            unit: String::new(),
-            direction: ParameterDirection::Unspecified,
-            storage: FieldStorage::Value,
-            default: None,
-        };
-        validate_candidate(&f.project).unwrap();
-        (f, next)
-    }
-    pub fn wide_payload() -> Payload {
-        let mut f = payload();
-        let record = f.project.elements[&f.leaf].parent.unwrap();
-        for (owner, template, count) in [(f.item, f.origin, 95), (record, f.leaf, 127)] {
-            for index in 0..count {
-                let body = f.project.elements[&template].shared().unwrap().clone();
-                let id = f
-                    .project
-                    .add_element(
-                        Kind::DataField,
-                        Layer::Oa,
-                        &format!("Field {template} {index}"),
-                        Some(owner),
-                    )
-                    .unwrap();
-                *f.project
-                    .elements
-                    .get_mut(&id)
-                    .unwrap()
-                    .shared_mut()
-                    .unwrap() = body;
-            }
-        }
-        f
-    }
-    #[test]
-    fn roots_and_one_hop_children_do_not_expand_unrelated_payload_branches() {
-        let mut f = wide_payload();
-        let exchange = &f.project.relations[&f.exchange];
-        let direct = roots(&f.project, exchange, &MessageKind::Call);
-        assert_eq!(direct.len(), 96);
-        assert!(direct.iter().all(|choice| choice.key.path.is_empty()));
-        let representative = choices(&f.project, exchange, &MessageKind::Call).unwrap();
-        assert_eq!(representative.len(), 96 * 129);
-        for root in &direct {
-            assert_eq!(
-                resolve(&f.project, exchange, &MessageKind::Call, &root.key),
-                Some(root.clone())
-            );
-        }
-        let nested = children(&f.project, exchange, &MessageKind::Call, &direct[0].key).unwrap();
-        assert_eq!(nested.len(), 128);
-        for child in &nested {
-            assert_eq!(
-                resolve(&f.project, exchange, &MessageKind::Call, &child.key),
-                Some(child.clone())
-            );
-            assert!(child.label.ends_with(" · In"));
-        }
-        // A temporarily over-limit model still exposes its unrelated root fields;
-        // the editor must not expand the whole graph before showing a choice.
-        for index in 0..32 {
-            let body = f.project.elements[&f.origin].shared().unwrap().clone();
-            let id = f
-                .project
-                .add_element(
-                    Kind::DataField,
-                    Layer::Oa,
-                    &format!("Extra {index}"),
-                    Some(f.item),
-                )
-                .unwrap();
-            *f.project
-                .elements
-                .get_mut(&id)
-                .unwrap()
-                .shared_mut()
-                .unwrap() = body;
-        }
-        let exchange = &f.project.relations[&f.exchange];
-        assert!(choices(&f.project, exchange, &MessageKind::Call).is_err());
-        assert_eq!(roots(&f.project, exchange, &MessageKind::Call).len(), 128);
-        assert_eq!(
-            children(&f.project, exchange, &MessageKind::Call, &direct[0].key)
-                .unwrap()
-                .len(),
-            128
-        );
-    }
-    #[test]
-    fn recursive_records_can_be_drilled_into_and_valid_imported_paths_resolve() {
-        let (f, next) = recursive_payload();
-        let exchange = &f.project.relations[&f.exchange];
-        let record = FieldPathKey {
-            path: vec![f.origin],
-            field: next,
-        };
-        let nested = children(&f.project, exchange, &MessageKind::Call, &record).unwrap();
-        let leaf = nested.iter().find(|c| c.key.field == f.leaf).unwrap();
-        assert_eq!(leaf.key.path, vec![f.origin, next]);
-        assert!(
-            !choices(&f.project, exchange, &MessageKind::Call)
-                .unwrap()
-                .iter()
-                .any(|c| c.key == leaf.key)
-        );
-        assert_eq!(
-            resolve(&f.project, exchange, &MessageKind::Call, &leaf.key),
-            Some(leaf.clone())
-        );
-        assert_eq!(parent(&leaf.key), Some(record));
-        let deepest = FieldPathKey {
-            path: std::iter::once(f.origin)
-                .chain(std::iter::repeat_n(next, data::MAX_VALUE_PATH_DEPTH - 1))
-                .collect(),
-            field: next,
-        };
-        assert!(resolve(&f.project, exchange, &MessageKind::Call, &deepest).is_some());
-        assert!(
-            children(&f.project, exchange, &MessageKind::Call, &deepest)
-                .unwrap_err()
-                .contains("128")
-        );
-    }
-}

crates/oa-desktop/src/diagram.rs

@@ -292,7 +292,6 @@ impl DiagramCanvas<'_> {
             request.placement = Some(node);
         } else if let Some(edge) = self
             .hit_label(&scene.routed, local)
-            .or_else(|| self.hit_association_label(&scene.routed, local))
             .or_else(|| self.hit_edge(&scene.routed, local).map(|(id, _)| id))
         {
             request.object = edge;
@@ -370,33 +369,6 @@ impl DiagramCanvas<'_> {
             })
             .map(|edge| edge.id)
     }
-    fn hit_association_label(&self, routed: &RoutedView, p: Point) -> Option<Id> {
-        let p = self.world(p);
-        routed
-            .edges
-            .values()
-            .flat_map(|edge| {
-                self.project
-                    .relations
-                    .get(&edge.id)
-                    .into_iter()
-                    .flat_map(move |relation| routing::association_end_geometry(relation, edge))
-                    .map(move |end| (edge.id, end.label))
-            })
-            .filter(|(_, label)| {
-                Rectangle::new(
-                    point(label.bounds.position),
-                    Size::new(label.bounds.size.width, label.bounds.size.height),
-                )
-                .contains(p)
-            })
-            .min_by(|a, b| {
-                p.distance(point(a.1.center))
-                    .total_cmp(&p.distance(point(b.1.center)))
-                    .then(a.0.cmp(&b.0))
-            })
-            .map(|(id, _)| id)
-    }
     fn preview_diagram(&self, state: &State) -> Diagram {
         let mut diagram = self.project.diagrams[&self.diagram].clone();
         if let (Some((id, _, original)), Some(preview)) = (state.drag, state.preview) {
@@ -753,10 +725,7 @@ impl canvas::Program<Message> for DiagramCanvas<'_> {
                     state.drag = Some((id, p, position));
                     state.preview = Some(position);
                     Some(Action::publish(Message::SelectNode(id)).and_capture())
-                } else if let Some(id) = self
-                    .hit_label(&scene.routed, p)
-                    .or_else(|| self.hit_association_label(&scene.routed, p))
-                {
+                } else if let Some(id) = self.hit_label(&scene.routed, p) {
                     Some(Action::publish(Message::Select(id)).and_capture())
                 } else if let Some((id, segment)) = self.hit_edge(&scene.routed, p) {
                     if id == self.selected
@@ -1041,37 +1010,6 @@ impl canvas::Program<Message> for DiagramCanvas<'_> {
                     ..Default::default()
                 });
             }
-            if let Some(relation) = self.project.relations.get(&edge.id) {
-                for end in routing::association_end_geometry(relation, routed) {
-                    if end.navigable {
-                        let [a, tip, b] = navigation_mark(end.tip, end.inward);
-                        f.stroke(
-                            &Path::new(|p| {
-                                p.move_to(a);
-                                p.line_to(tip);
-                                p.line_to(b);
-                            }),
-                            Stroke::default().with_color(color).with_width(1.7),
-                        );
-                    }
-                    let label = &end.label;
-                    f.fill_rectangle(
-                        point(label.bounds.position),
-                        Size::new(label.bounds.size.width, label.bounds.size.height),
-                        Color::WHITE,
-                    );
-                    f.fill_text(Text {
-                        content: label.text.clone(),
-                        position: point(label.center),
-                        color: if active { style::TEAL } else { style::MUTED },
-                        size: 13.into(),
-                        align_x: iced::widget::text::Alignment::Center,
-                        align_y: iced::alignment::Vertical::Center,
-                        max_width: f32::INFINITY,
-                        ..Default::default()
-                    });
-                }
-            }
         }
         for n in &view.nodes {
             if !containers.contains(&n.id) {
@@ -1319,17 +1257,6 @@ fn endpoint_position(view: &ProjectedView, id: Id) -> Option<Position> {
                 })
         })
 }
-fn navigation_mark(tip: Position, inward: Position) -> [Point; 3] {
-    let tip = point(tip);
-    let delta = point(inward) - tip;
-    let direction = delta / delta.x.hypot(delta.y).max(0.001);
-    let normal = Vector::new(-direction.y, direction.x) * 4.;
-    [
-        tip + direction * 9. + normal,
-        tip,
-        tip + direction * 9. - normal,
-    ]
-}
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum PortGlyph {
     Function,
@@ -1617,21 +1544,6 @@ pub fn export_svg(p: &Project, diagram: Id) -> String {
         if !label.text.is_empty() {
             svg.push_str(&format!("<rect x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" fill=\"white\"/><text x=\"{}\" y=\"{}\" text-anchor=\"middle\" dominant-baseline=\"central\" font-family=\"sans-serif\" font-size=\"13\" fill=\"#637487\">{}</text>",label.bounds.position.x,label.bounds.position.y,label.bounds.size.width,label.bounds.size.height,label.center.x,label.center.y,escape(&label.text)));
         }
-        if let Some(relation) = p.relations.get(&edge.id) {
-            for end in routing::association_end_geometry(relation, route) {
-                let side = if end.source_end { "source" } else { "target" };
-                svg.push_str(&format!(
-                    "<g data-association=\"{}\" data-end=\"{side}\">",
-                    edge.id
-                ));
-                if end.navigable {
-                    let [a, tip, b] = navigation_mark(end.tip, end.inward);
-                    svg.push_str(&format!("<path data-navigation=\"{side}\" d=\"M {} {} L {} {} L {} {}\" fill=\"none\" stroke=\"#8999a9\" stroke-width=\"1.7\"/>",a.x,a.y,tip.x,tip.y,b.x,b.y));
-                }
-                let label = &end.label;
-                svg.push_str(&format!("<rect x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" fill=\"white\"/><text x=\"{}\" y=\"{}\" text-anchor=\"middle\" dominant-baseline=\"central\" font-family=\"sans-serif\" font-size=\"13\" fill=\"#637487\">{}</text></g>",label.bounds.position.x,label.bounds.position.y,label.bounds.size.width,label.bounds.size.height,label.center.x,label.center.y,escape(&label.text)));
-            }
-        }
     }
     for n in &view.nodes {
         if !containers.contains(&n.id) {
@@ -2441,98 +2353,6 @@ mod tests {
         assert!(geometry.bounds.position.y <= route.label.bounds.position.y);
     }
     #[test]
-    fn association_end_contracts_share_svg_geometry_and_select_without_moving_name_label() {
-        for self_loop in [false, true] {
-            let mut p = Project::empty();
-            let a = p.add(Kind::DataType, "Tree", 100., 100.);
-            let b = if self_loop {
-                a
-            } else {
-                p.add(Kind::DataType, "Branch", 650., 100.)
-            };
-            for id in BTreeSet::from([a, b]) {
-                *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::DataType {
-                    definition: DataTypeDefinition::Record { supertype: None },
-                    default: None,
-                    unit: String::new(),
-                };
-            }
-            let edge = p.relate(RelationKind::DataAssociation, "Hierarchy", a, b);
-            p.relations.get_mut(&edge).unwrap().body = RelationBody::DataAssociation {
-                source: a,
-                target: b,
-                source_role: "parent".into(),
-                target_role: "children".into(),
-                source_minimum: 0,
-                source_maximum: Some(1),
-                target_minimum: 0,
-                target_maximum: None,
-                source_navigable: false,
-                target_navigable: true,
-            };
-            let diagram = p.ensure_diagram(Layer::Oa);
-            let projected = project_view(&p, diagram);
-            assert!(
-                !projected
-                    .edges
-                    .iter()
-                    .find(|e| e.id == edge)
-                    .unwrap()
-                    .oriented
-            );
-            let routed = route_diagram(&p, &p.diagrams[&diagram], &projected);
-            let ends = routing::association_end_geometry(&p.relations[&edge], &routed.edges[&edge]);
-            assert_eq!(ends.len(), 2);
-            let svg = export_svg(&p, diagram);
-            assert!(svg.contains("parent [0..1]</text>"));
-            assert!(svg.contains("children [0..*]</text>"));
-            assert!(!svg.contains("data-navigation=\"source\""));
-            assert!(svg.contains("data-navigation=\"target\""));
-            let mut canvas = DiagramCanvas {
-                project: &p,
-                diagram,
-                selected: edge,
-                zoom: 0.7,
-                pan: Vector::new(350., 350.),
-                context: Context {
-                    document: p.id,
-                    diagram,
-                    revision: 0,
-                    epoch: 0,
-                },
-                selected_bend: None,
-                editable: true,
-                connection: None,
-            };
-            for end in ends {
-                assert!(svg.contains(&format!(
-                    "x=\"{}\" y=\"{}\" text-anchor",
-                    end.label.center.x, end.label.center.y
-                )));
-                let at = Point::new(
-                    end.label.center.x * canvas.zoom + canvas.pan.x,
-                    end.label.center.y * canvas.zoom + canvas.pan.y,
-                );
-                let mut state = State::default();
-                assert_eq!(canvas.hit_association_label(&routed, at), Some(edge));
-                assert!(
-                    matches!(pointer(&canvas,&mut state,mouse::Event::ButtonPressed(mouse::Button::Left),at),Some(Message::Select(id)) if id==edge)
-                );
-                assert!(
-                    state.route_drag.is_none(),
-                    "Endpoint contract labels never drag the association name"
-                );
-                assert_eq!(
-                    canvas
-                        .context_request(&state, at, Rectangle::with_size(Size::new(1800., 1200.)))
-                        .object,
-                    edge
-                );
-                canvas.selected = p.id;
-            }
-        }
-    }
-    #[test]
     fn detached_label_selects_connection_and_occluding_card_owns_its_hit() {
         let (mut p, diagram, edge) = route_fixture();
         p.diagrams.get_mut(&diagram).unwrap().routes[0].label = Some(EdgeLabel {

crates/oa-desktop/src/forms.rs

@@ -14,7 +14,6 @@ use iced::{
 use oa_core::*;
 use serde_json::{Value, json};
 use std::collections::{BTreeMap, BTreeSet};
-mod data_fields;
 mod port_fields;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -39,9 +38,6 @@ pub struct Draft {
     baseline: Value,
     pub inputs: BTreeMap<String, Input>,
     pub exact_strings: bool,
-    context: Option<Value>,
-    pub semantic_groups: bool,
-    constructor_drafts: BTreeMap<(String, String), (Value, BTreeMap<String, Input>)>,
     port_contract_drafts: BTreeMap<String, Value>,
 }
 
@@ -79,9 +75,6 @@ impl Draft {
             value,
             inputs: BTreeMap::new(),
             exact_strings: false,
-            context: None,
-            semantic_groups: false,
-            constructor_drafts: BTreeMap::new(),
             port_contract_drafts: BTreeMap::new(),
         };
         draft.rebuild();
@@ -136,32 +129,8 @@ impl Draft {
         }
     }
     pub fn materialize(&self) -> Result<Value, String> {
-        self.materialize_inputs(|_| true)
-    }
-    /// Read-only context for dependent controls. Workflow proposals never replace
-    /// the authored value or its input buffers and are not used by command().
-    pub fn context_value(&self) -> Value {
-        self.context
-            .clone()
-            .unwrap_or_else(|| self.materialize().unwrap_or_else(|_| self.value.clone()))
-    }
-    pub fn set_context(&mut self, context: Option<Value>) {
-        self.context = context;
-    }
-    /// Materialize selected scalar subtrees without parsing retained, unselected drafts.
-    pub fn materialize_scopes(&self, scopes: &[String]) -> Result<Value, String> {
-        self.materialize_inputs(|path| {
-            scopes
-                .iter()
-                .any(|root| path == root || path.starts_with(&format!("{root}/")))
-        })
-    }
-    fn materialize_inputs(&self, include: impl Fn(&str) -> bool) -> Result<Value, String> {
         let mut value = self.value.clone();
         for (path, input) in &self.inputs {
-            if !include(path) {
-                continue;
-            }
             let Some(target) = value.pointer_mut(path) else {
                 continue;
             };
@@ -232,166 +201,6 @@ impl Draft {
         self.rebuild();
         Ok(())
     }
-    /// Replace a workflow-authorized subtree without parsing unrelated inputs,
-    /// including an invalid value which this replacement deliberately removes.
-    pub fn shape_scoped(&mut self, path: &str, value: Value) -> Result<(), String> {
-        *self
-            .value
-            .pointer_mut(path)
-            .ok_or("Property no longer exists.")? = value;
-        self.rebuild_retaining(|old| (!within(old, path)).then(|| old.to_owned()));
-        Ok(())
-    }
-    /// Preserve each selected constructor branch, including incomplete raw input
-    /// and editor state. No sibling fields are parsed or cleared by a switch.
-    pub fn variant_scoped(&mut self, path: &str, proposed: Value) -> Result<(), String> {
-        let current = self
-            .value
-            .pointer(path)
-            .ok_or("Property no longer exists.")?
-            .clone();
-        if same_variant(&current, &proposed) {
-            return Ok(());
-        }
-        let constructor = path.ends_with("/DataType/definition")
-            || path.ends_with("/Port/contract")
-            || path.ends_with("/Occurrence/body")
-            || path.ends_with("/Event/body")
-            || path.ends_with("/message_kind");
-        if !constructor {
-            return self.shape_scoped(path, proposed);
-        }
-        // Input/output direction changes carry the item declaration. Read those
-        // raw reference strings before stashing their editor buffers so an
-        // incomplete reference cannot silently fall back to its stored UUID.
-        let port_current = if path.ends_with("/Port/contract") {
-            self.materialize_scopes(&[path.to_owned()])?
-                .pointer(path)
-                .cloned()
-        } else {
-            None
-        };
-        let tag = |value: &Value| {
-            value
-                .as_str()
-                .or_else(|| value.as_object()?.keys().next().map(String::as_str))
-                .unwrap_or("")
-                .to_owned()
-        };
-        let previous_key = (path.to_owned(), tag(&current));
-        let next_key = (path.to_owned(), tag(&proposed));
-        let mut inputs = BTreeMap::new();
-        for key in self
-            .inputs
-            .keys()
-            .filter(|key| within(key, path))
-            .cloned()
-            .collect::<Vec<_>>()
-        {
-            inputs.insert(key.clone(), self.inputs.remove(&key).unwrap());
-        }
-        self.constructor_drafts
-            .insert(previous_key, (current.clone(), inputs));
-        let saved = self.constructor_drafts.remove(&next_key);
-        let (value, restored) = if let Some(saved) = saved {
-            saved
-        } else {
-            let value = if path.ends_with("/Port/contract") {
-                port_fields::switch_contract(
-                    port_current.as_ref().unwrap_or(&current),
-                    proposed,
-                    &mut BTreeMap::new(),
-                )
-            } else {
-                proposed
-            };
-            (value, BTreeMap::new())
-        };
-        self.shape_scoped(path, value)?;
-        self.inputs.extend(restored);
-        Ok(())
-    }
-    fn rebuild_retaining(&mut self, new_path: impl Fn(&str) -> Option<String>) {
-        let previous = std::mem::take(&mut self.inputs);
-        self.rebuild();
-        for (path, input) in previous {
-            if let Some(path) = new_path(&path)
-                && self.inputs.contains_key(&path)
-            {
-                self.inputs.insert(path, input);
-            }
-        }
-    }
-    pub fn array_scoped(
-        &mut self,
-        path: &str,
-        index: Option<usize>,
-        direction: i32,
-    ) -> Result<(), String> {
-        let mut candidate = self.value.clone();
-        let count = candidate
-            .pointer(path)
-            .and_then(Value::as_array)
-            .ok_or("List no longer exists.")?
-            .len();
-        edit_array(&mut candidate, path, index, direction)?;
-        self.value = candidate;
-        self.rebuild_retaining(|old| {
-            let Some(tail) = old.strip_prefix(&format!("{path}/")) else {
-                return Some(old.to_owned());
-            };
-            let (number, rest) = tail.split_once('/').unwrap_or((tail, ""));
-            let position = number.parse::<usize>().ok()?;
-            let position = match index {
-                Some(index) if direction == 0 && position == index => return None,
-                Some(index) if direction == 0 && position > index => position - 1,
-                Some(index) if direction != 0 => {
-                    let target = (index as i32 + direction).clamp(0, count as i32 - 1) as usize;
-                    if position == index {
-                        target
-                    } else if position == target {
-                        index
-                    } else {
-                        position
-                    }
-                }
-                _ => position,
-            };
-            Some(if rest.is_empty() {
-                format!("{path}/{position}")
-            } else {
-                format!("{path}/{position}/{rest}")
-            })
-        });
-        Ok(())
-    }
-    pub fn append_scoped(&mut self, path: &str, value: Value) -> Result<(), String> {
-        self.value
-            .pointer_mut(path)
-            .and_then(Value::as_array_mut)
-            .ok_or("List no longer exists.")?
-            .push(value);
-        self.rebuild_retaining(|path| Some(path.to_owned()));
-        Ok(())
-    }
-    pub fn value_path_scoped(
-        &mut self,
-        path: &str,
-        key: crate::data_values::FieldPathKey,
-    ) -> Result<(), String> {
-        let row = self
-            .value
-            .pointer_mut(path)
-            .and_then(Value::as_object_mut)
-            .ok_or("Message value no longer exists.")?;
-        row.insert("path".into(), json!(key.path));
-        row.insert("field".into(), json!(key.field));
-        self.rebuild_retaining(|old| {
-            (!within(old, &format!("{path}/path")) && !within(old, &format!("{path}/field")))
-                .then(|| old.to_owned())
-        });
-        Ok(())
-    }
     pub fn array(
         &mut self,
         path: &str,
@@ -399,34 +208,36 @@ impl Draft {
         direction: i32,
     ) -> Result<(), String> {
         let mut candidate = self.materialize()?;
-        edit_array(&mut candidate, path, index, direction)?;
-        self.value = candidate;
-        self.rebuild();
-        Ok(())
-    }
-    pub fn append(&mut self, path: &str, value: Value) -> Result<(), String> {
-        let mut candidate = self.materialize()?;
-        candidate
+        let items = candidate
             .pointer_mut(path)
             .and_then(Value::as_array_mut)
-            .ok_or("List no longer exists.")?
-            .push(value);
-        self.value = candidate;
-        self.rebuild();
-        Ok(())
-    }
-    pub fn value_path(
-        &mut self,
-        path: &str,
-        key: crate::data_values::FieldPathKey,
-    ) -> Result<(), String> {
-        let mut candidate = self.materialize()?;
-        let row = candidate
-            .pointer_mut(path)
-            .and_then(Value::as_object_mut)
-            .ok_or("Message value no longer exists.")?;
-        row.insert("path".into(), json!(key.path));
-        row.insert("field".into(), json!(key.field));
+            .ok_or("List no longer exists.")?;
+        match index {
+            None => items.push(if path.ends_with("literals") {
+                json!("New value")
+            } else if path.ends_with("bindings") {
+                json!({"referenced": Id::nil(), "local": Id::nil()})
+            } else if path.ends_with("values") {
+                json!({"field": Id::nil(), "expression": ""})
+            } else if path.ends_with("routes") {
+                json!({"edge": Id::nil(), "waypoints": [], "label": null})
+            } else if path.ends_with("waypoints") {
+                json!({"x": 0.0, "y": 0.0})
+            } else if path.ends_with("port_anchors") {
+                json!({"port": Id::nil(), "side": "Right", "offset": 0.5})
+            } else {
+                json!(Id::nil())
+            }),
+            Some(i) if i < items.len() => {
+                if direction == 0 {
+                    items.remove(i);
+                } else {
+                    let target = (i as i32 + direction).clamp(0, items.len() as i32 - 1) as usize;
+                    items.swap(i, target);
+                }
+            }
+            _ => return Err("List item no longer exists.".into()),
+        }
         self.value = candidate;
         self.rebuild();
         Ok(())
@@ -501,51 +312,6 @@ impl Draft {
     }
 }
 
-fn within(path: &str, root: &str) -> bool {
-    path == root
-        || path
-            .strip_prefix(root)
-            .is_some_and(|tail| tail.starts_with('/'))
-}
-fn edit_array(
-    value: &mut Value,
-    path: &str,
-    index: Option<usize>,
-    direction: i32,
-) -> Result<(), String> {
-    let items = value
-        .pointer_mut(path)
-        .and_then(Value::as_array_mut)
-        .ok_or("List no longer exists.")?;
-    match index {
-        None => items.push(if path.ends_with("literals") {
-            json!("New value")
-        } else if path.ends_with("bindings") {
-            json!({"referenced": Id::nil(), "local": Id::nil()})
-        } else if path.ends_with("values") {
-            json!({"path": [], "field": Id::nil(), "expression": ""})
-        } else if path.ends_with("routes") {
-            json!({"edge": Id::nil(), "waypoints": [], "label": null})
-        } else if path.ends_with("waypoints") {
-            json!({"x": 0.0, "y": 0.0})
-        } else if path.ends_with("port_anchors") {
-            json!({"port": Id::nil(), "side": "Right", "offset": 0.5})
-        } else {
-            json!(Id::nil())
-        }),
-        Some(i) if i < items.len() => {
-            if direction == 0 {
-                items.remove(i);
-            } else {
-                let target = (i as i32 + direction).clamp(0, items.len() as i32 - 1) as usize;
-                items.swap(i, target);
-            }
-        }
-        _ => return Err("List item no longer exists.".into()),
-    }
-    Ok(())
-}
-
 fn friendly(name: &str) -> String {
     match name {
         "id" => "UUID identity".into(),
@@ -645,7 +411,6 @@ fn reference(path: &str) -> bool {
             | "Named"
             | "diagram"
             | "machine"
-            | "supertype"
     ) || matches!(
         parent,
         "items"
@@ -675,7 +440,6 @@ fn optional_reference(path: &str) -> bool {
             | "reply_to"
             | "lifeline"
             | "state"
-            | "supertype"
     )
 }
 fn multiline(path: &str) -> bool {
@@ -698,22 +462,15 @@ fn free_string(path: &str) -> bool {
     multiline(path)
         || matches!(
             path.rsplit('/').next(),
-            Some("name" | "uri" | "revision" | "fragment" | "unit" | "source_role" | "target_role")
+            Some("name" | "uri" | "revision" | "fragment" | "unit")
         )
         || path.split('/').rev().nth(1) == Some("literals")
-        || (path.contains("/default/")
-            && matches!(path.rsplit('/').next(), Some("String" | "Enumeration")))
 }
 
 // These are choices for the closed model, not a second validation boundary.
 // A current reference is always retained, even while other draft fields make it
 // incompatible. Applying the complete draft remains the core validator's job.
-pub(crate) fn reference_choices(
-    draft: &Draft,
-    project: &Project,
-    path: &str,
-    current: Id,
-) -> Vec<Choice> {
+fn reference_choices(draft: &Draft, project: &Project, path: &str, current: Id) -> Vec<Choice> {
     let identities = project.identities().into_iter().collect::<BTreeMap<_, _>>();
     let compatible = reference_ids(draft, project, path);
     let mut objects = compatible
@@ -765,7 +522,7 @@ pub(crate) fn reference_choices(
 }
 
 fn reference_ids(draft: &Draft, project: &Project, path: &str) -> Vec<Id> {
-    let value = draft.context_value();
+    let value = draft.materialize().unwrap_or_else(|_| draft.value.clone());
     if path.starts_with("/port_anchors/") && path.ends_with("/port") {
         let owner = value
             .get("element")
@@ -905,37 +662,21 @@ fn reference_ids(draft: &Draft, project: &Project, path: &str) -> Vec<Id> {
             .collect();
     }
     if field == "field" {
-        let address_path = path
-            .strip_suffix("/field")
-            .and_then(|row| value.pointer(&format!("{row}/path")))
-            .and_then(|v| serde_json::from_value::<Vec<Id>>(v.clone()).ok())
-            .unwrap_or_default();
         return element
             .as_ref()
             .and_then(|e| match e.shared()? {
                 SharedBody::Occurrence {
                     body:
                         OccurrenceBody::Exchange {
-                            exchange: Some(id),
-                            message_kind,
-                            ..
+                            exchange: Some(id), ..
                         },
                     ..
-                } => project
-                    .relations
-                    .get(id)
-                    .and_then(|r| crate::data_values::choices(project, r, message_kind).ok()),
+                } => project.relations.get(id),
                 _ => None,
             })
-            .unwrap_or_default()
-            .into_iter()
-            .filter(|choice| choice.key.path == address_path)
-            .map(|choice| choice.key.field)
-            .collect::<BTreeSet<_>>()
-            .into_iter()
-            .collect();
+            .map(|r| validation::carried_fields(project, r).into_iter().collect())
+            .unwrap_or_default();
     }
-
     let scenario = element
         .as_ref()
         .and_then(|e| e.parent)
@@ -966,40 +707,6 @@ fn reference_ids(draft: &Draft, project: &Project, path: &str) -> Vec<Id> {
                 return false;
             }
             match field {
-                "supertype" => element.as_ref().is_some_and(|owner| {
-                    if candidate.id == owner.id
-                        || candidate.kind() != owner.kind()
-                        || (candidate.kind() == Kind::DataType
-                            && !data::is_record(project, candidate.id))
-                    {
-                        return false;
-                    }
-                    if let (
-                        Some(SharedBody::ExchangeItem {
-                            kind, mechanism, ..
-                        }),
-                        Some(SharedBody::ExchangeItem {
-                            kind: base_kind,
-                            mechanism: base_mechanism,
-                            ..
-                        }),
-                    ) = (owner.shared(), candidate.shared())
-                        && (kind != base_kind
-                            || (*base_mechanism != ExchangeMechanism::Unspecified
-                                && mechanism != base_mechanism))
-                    {
-                        return false;
-                    }
-                    let mut next = Some(candidate.id);
-                    let mut seen = BTreeSet::new();
-                    while let Some(id) = next {
-                        if id == owner.id || !seen.insert(id) {
-                            return false;
-                        }
-                        next = project.elements.get(&id).and_then(data::supertype);
-                    }
-                    true
-                }),
                 "machine" => candidate.kind() == Kind::StateMachine,
                 "parent" => element.as_ref().is_some_and(|child| {
                     if candidate.id == draft.original
@@ -1351,21 +1058,6 @@ fn variants(path: &str, value: &Value, kind: RecordKind) -> Vec<(String, Value)>
     let words: &[&str] = match field {
         "side" if path.starts_with("/port_anchors/") => &["Left", "Right", "Top", "Bottom"],
         "layer" => &["Oa", "Sa"],
-        "mechanism" => &["Unspecified", "Flow", "Event", "Operation", "SharedData"],
-        "storage" => &["Value", "Reference"],
-        "direction" if path.contains("/Port/legacy/") => &["In", "Out", "InOut"],
-        "direction" if path.contains("DataField") => {
-            &["Unspecified", "In", "Out", "InOut", "Return"]
-        }
-        "transmission" => &[
-            "Unspecified",
-            "Synchronous",
-            "Asynchronous",
-            "Unicast",
-            "Multicast",
-            "Broadcast",
-        ],
-        "acquisition" => &["Unspecified", "Read", "Accept"],
         "operator" => &["Alternative", "Parallel", "Loop", "Optional"],
         "viewpoint" if path.contains("/Oa/") => &[
             "OperationalActivity",
@@ -1374,7 +1066,7 @@ fn variants(path: &str, value: &Value, kind: RecordKind) -> Vec<(String, Value)>
         ],
         "viewpoint" => &["Functional", "BoundaryInterface", "MixedLegacy"],
         "phase" => &["Entry", "Do", "Exit"],
-        "kind" if path.contains("ExchangeItem") => &["Information", "Material", "Energy"],
+        "kind" if path.contains("ExchangeItem") => &["Information", "Material", "Energy", "Event"],
         "kind" if path.contains("Control") => &["Choice", "Merge", "Fork", "Join", "Loop"],
         "kind" if path.contains("State") => &[
             "State",
@@ -1440,20 +1132,11 @@ fn variants(path: &str, value: &Value, kind: RecordKind) -> Vec<(String, Value)>
     if field == "definition" {
         return vec![
             ("Boolean".into(), json!("Boolean")),
-            (
-                "Integer".into(),
-                json!({"Integer":{"minimum":null,"maximum":null}}),
-            ),
-            (
-                "Real".into(),
-                json!({"Real":{"minimum":null,"maximum":null}}),
-            ),
-            (
-                "Text".into(),
-                json!({"String":{"minimum_length":0,"maximum_length":null}}),
-            ),
+            ("Integer".into(), json!("Integer")),
+            ("Real".into(), json!("Real")),
+            ("Text".into(), json!("String")),
             ("Enumeration".into(), json!({"Enumeration":{"literals":[]}})),
-            ("Record".into(), json!({"Record":{"supertype":null}})),
+            ("Record".into(), json!("Record")),
         ];
     }
     if field == "type_ref" {
@@ -1582,22 +1265,6 @@ pub fn view<'a>(draft: &'a Draft, project: &'a Project) -> View<'a, Message> {
     content.into()
 }
 
-/// Render one closed property subtree for a workflow-owned typed draft.
-/// The caller routes messages to that draft and authorizes the selected scope.
-pub fn scoped<'a>(
-    draft: &'a Draft,
-    project: &'a Project,
-    path: &str,
-    label: &str,
-) -> View<'a, Message> {
-    match draft.value.pointer(path) {
-        Some(value) => property(draft, project, value, path, label, false),
-        None => text("This property is not applicable to the current target.")
-            .size(12)
-            .into(),
-    }
-}
-
 fn property<'a>(
     draft: &'a Draft,
     project: &'a Project,
@@ -1606,11 +1273,8 @@ fn property<'a>(
     label: &str,
     skip_variant: bool,
 ) -> View<'a, Message> {
-    if let Some(view) = data_fields::property(draft, project, value, path) {
-        return view;
-    }
     let label_view = || text(label.to_owned()).size(11).color(style::MUTED);
-    if path.ends_with("/Port/legacy") && !draft.semantic_groups {
+    if path.ends_with("/Port/legacy") {
         let mut content = column![].spacing(4);
         if !value.is_null() {
             content = content.push(
@@ -1624,29 +1288,6 @@ fn property<'a>(
         }
         return content.into();
     }
-    if path.ends_with("/Port/legacy") && draft.semantic_groups && !skip_variant {
-        let mut content = column![
-            label_view(),
-            text(
-                "Retained generic association is part of this group. Change or clear it explicitly."
-            )
-            .size(11)
-        ]
-        .spacing(5);
-        if value.is_null() {
-            content = content.push(button(text("Add generic association").size(11)).on_press(
-                Message::FieldShape(path.into(), json!({"direction":"InOut","interface":null})),
-            ));
-        } else {
-            content = content
-                .push(property(draft, project, value, path, label, true))
-                .push(
-                    button(text("Clear generic association").size(11))
-                        .on_press(Message::FieldShape(path.into(), Value::Null)),
-                );
-        }
-        return content.into();
-    }
     let enum_choices = if skip_variant {
         vec![]
     } else {
@@ -1904,73 +1545,6 @@ fn property<'a>(
 mod tests {
     use super::*;
 
-    #[test]
-    fn semantic_port_group_choices_use_combined_owner_and_retain_invalid_transferred_items() {
-        let mut p = Project::empty();
-        let function = p
-            .add_element(Kind::Function, Layer::Sa, "Function", None)
-            .unwrap();
-        let component = p
-            .add_element(Kind::System, Layer::Sa, "Component", None)
-            .unwrap();
-        let item = p
-            .add_element(Kind::ExchangeItem, Layer::Sa, "Item", None)
-            .unwrap();
-        let id = Id::new_v4();
-        p.elements.insert(
-            id,
-            ports::make_port(
-                &p,
-                id,
-                function,
-                "Port",
-                PortContract::FunctionInput {
-                    incoming_items: vec![item],
-                },
-            )
-            .unwrap(),
-        );
-        let mut draft = Draft::from_project(&p, id).unwrap();
-        draft.semantic_groups = true;
-        let path = "/body/Sa/Shared/Port/contract";
-        let input = format!("{path}/FunctionInput/incoming_items/0");
-        draft.input(&input, "incomplete-id".into());
-        let cursor = draft.inputs[&input].editor.cursor();
-        draft
-            .variant_scoped(path, json!({"FunctionOutput":{"outgoing_items":[]}}))
-            .unwrap();
-        assert_eq!(
-            draft.inputs[&format!("{path}/FunctionOutput/outgoing_items/0")].raw,
-            "incomplete-id"
-        );
-        assert!(serde_json::from_value::<Element>(draft.materialize().unwrap()).is_err());
-        draft
-            .variant_scoped(path, json!({"FunctionInput":{"incoming_items":[]}}))
-            .unwrap();
-        assert_eq!(draft.inputs[&input].raw, "incomplete-id");
-        assert_eq!(draft.inputs[&input].editor.cursor(), cursor);
-        let choices =
-            port_fields::variants(&draft, &p, path, draft.value.pointer(path).unwrap()).unwrap();
-        assert!(
-            choices
-                .iter()
-                .any(|(_, v)| v.get("FunctionInput").is_some())
-        );
-        assert!(choices.iter().any(|(_, v)| *v == json!("Legacy")));
-        assert!(!choices.iter().any(|(_, v)| v.get("Component").is_some()));
-        let mut context = draft.value.clone();
-        context["parent"] = json!(component);
-        draft.set_context(Some(context));
-        let choices =
-            port_fields::variants(&draft, &p, path, draft.value.pointer(path).unwrap()).unwrap();
-        assert!(choices.iter().any(|(_, v)| v.get("Component").is_some()));
-        assert!(
-            !choices
-                .iter()
-                .any(|(_, v)| v.get("FunctionInput").is_some())
-        );
-    }
-
     fn ids(draft: &Draft, project: &Project, path: &str) -> Vec<Id> {
         reference_ids(draft, project, path)
     }
@@ -2501,8 +2075,6 @@ mod tests {
             Layer::Oa,
             SharedBody::ExchangeItem {
                 kind: ExchangeItemKind::Energy,
-                mechanism: ExchangeMechanism::Flow,
-                supertype: None,
             },
         );
         let mut draft = Draft::from_project(&p, item).unwrap();
@@ -2519,12 +2091,8 @@ mod tests {
         let interface = p
             .add_element(Kind::Interface, Layer::Oa, "Power contract", None)
             .unwrap();
-        p.relate(
-            RelationKind::InterfaceItemAllocation,
-            "Allocated item",
-            interface,
-            item,
-        );
+        p.elements.get_mut(&interface).unwrap().body =
+            ElementBody::shared_in(Layer::Oa, SharedBody::Interface { items: vec![item] });
         assert!(execute_batch(&p, &[draft.command().unwrap()]).is_err());
         assert!(draft.dirty());
         assert_eq!(p.elements[&item].layer(), Layer::Oa);

crates/oa-desktop/src/forms/data_fields.rs

@@ -1,934 +0,0 @@
-//! Typed data contracts use the same draft and command boundary as other properties.
-use super::*;
-use iced::widget::column;
-
-fn element(draft: &Draft, project: &Project) -> Option<Element> {
-    serde_json::from_value(draft.context_value())
-        .ok()
-        .or_else(|| project.elements.get(&draft.original).cloned())
-}
-
-fn definition(project: &Project, reference: &TypeRef) -> Option<DataTypeDefinition> {
-    Some(match reference {
-        TypeRef::Boolean => DataTypeDefinition::Boolean,
-        TypeRef::Integer => DataTypeDefinition::Integer {
-            minimum: None,
-            maximum: None,
-        },
-        TypeRef::Real => DataTypeDefinition::Real {
-            minimum: None,
-            maximum: None,
-        },
-        TypeRef::String => DataTypeDefinition::String {
-            minimum_length: 0,
-            maximum_length: None,
-        },
-        TypeRef::Named(id) => match project.elements.get(id)?.shared()? {
-            SharedBody::DataType { definition, .. } => definition.clone(),
-            _ => return None,
-        },
-    })
-}
-
-fn literal(definition: &DataTypeDefinition) -> Option<Value> {
-    Some(match definition {
-        DataTypeDefinition::Boolean => json!({"Boolean": false}),
-        DataTypeDefinition::Integer { minimum, .. } => json!({"Integer": minimum.unwrap_or(0)}),
-        DataTypeDefinition::Real { minimum, .. } => json!({"Real": minimum.unwrap_or(0.)}),
-        DataTypeDefinition::String { .. } => json!({"String": ""}),
-        DataTypeDefinition::Enumeration { literals } => json!({"Enumeration": literals.first()?}),
-        DataTypeDefinition::Record { .. } => return None,
-    })
-}
-
-pub(super) fn property<'a>(
-    draft: &'a Draft,
-    project: &'a Project,
-    value: &'a Value,
-    path: &str,
-) -> Option<View<'a, Message>> {
-    if path.split('/').rev().nth(1) == Some("values") && value.is_object() {
-        return Some(message_value(draft, project, value, path));
-    }
-    let leaf = path.rsplit('/').next()?;
-    if leaf == "direction" && path.contains("/DataField/") {
-        let operation = element(draft, project)
-            .and_then(|e| e.parent)
-            .and_then(|id| data::item_mechanism(project, id))
-            == Some(ExchangeMechanism::Operation);
-        if !operation {
-            let mut out = column![
-                text("Parameter direction").size(11).color(style::MUTED),
-                text("Unspecified · direction applies to direct Operation parameters.").size(11)
-            ]
-            .spacing(5);
-            if value.as_str() != Some("Unspecified") {
-                out = out
-                    .push(
-                        text(format!(
-                            "Current {:?} requires review.",
-                            value.as_str().unwrap_or_default()
-                        ))
-                        .size(11),
-                    )
-                    .push(
-                        button(text("Use Unspecified").size(11))
-                            .style(style::nav)
-                            .on_press(Message::FieldShape(path.into(), json!("Unspecified"))),
-                    );
-            }
-            return Some(out.into());
-        }
-    }
-    let bounded = (path.contains("/definition/Integer/") || path.contains("/definition/Real/"))
-        && matches!(leaf, "minimum" | "maximum");
-    let count_max = matches!(leaf, "maximum_length" | "source_maximum" | "target_maximum")
-        || (leaf == "maximum" && path.contains("/DataField/"));
-    if bounded || count_max {
-        let label = match leaf {
-            "minimum" => "Inclusive lower bound",
-            "maximum" if bounded => "Inclusive upper bound",
-            "maximum_length" => "Maximum Unicode characters",
-            "source_maximum" => "Source maximum count",
-            "target_maximum" => "Target maximum count",
-            _ => "Maximum count",
-        };
-        let mut out = column![text(label).size(11).color(style::MUTED)].spacing(5);
-        if value.is_null() {
-            out = out.push(
-                button(
-                    text(if bounded {
-                        "Unbounded · set bound"
-                    } else {
-                        "Unlimited · set maximum"
-                    })
-                    .size(12),
-                )
-                .style(style::nav)
-                .on_press(Message::FieldShape(
-                    path.into(),
-                    if path.contains("/Real/") {
-                        json!(0.)
-                    } else if count_max {
-                        let minimum_path = path.replace("maximum", "minimum");
-                        json!(
-                            draft
-                                .context_value()
-                                .pointer(&minimum_path)
-                                .and_then(Value::as_u64)
-                                .unwrap_or(1)
-                                .max(1)
-                        )
-                    } else {
-                        json!(0)
-                    },
-                )),
-            );
-        } else if let Some(input) = draft.inputs.get(path) {
-            let owned = path.to_owned();
-            out = out
-                .push(
-                    text_input("", &input.raw)
-                        .on_input(move |s| Message::Field(owned.clone(), s))
-                        .size(12)
-                        .padding(8),
-                )
-                .push(
-                    button(text("Clear bound").size(10))
-                        .style(style::nav)
-                        .on_press(Message::FieldShape(path.into(), Value::Null)),
-                );
-        }
-        return Some(out.into());
-    }
-    if leaf == "default" && (path.contains("/DataField/") || path.contains("/DataType/")) {
-        let owner = element(draft, project);
-        let (definition, collection, reference, minimum) =
-            match owner.as_ref().and_then(Element::shared) {
-                Some(SharedBody::DataType { definition, .. }) => {
-                    (Some(definition.clone()), false, false, 0)
-                }
-                Some(SharedBody::DataField {
-                    type_ref,
-                    storage,
-                    minimum,
-                    ..
-                }) => (
-                    definition(project, type_ref),
-                    true,
-                    *storage == FieldStorage::Reference,
-                    *minimum,
-                ),
-                _ => (None, false, false, 0),
-            };
-        let initial = definition.as_ref().and_then(literal);
-        let mut out = column![text("Default").size(11).color(style::MUTED)].spacing(6);
-        if reference {
-            out = out.push(
-                text("References have no literal default; they identify an existing record.")
-                    .size(11)
-                    .color(style::MUTED),
-            );
-        }
-        if value.is_null() {
-            out = out.push(text("Absent · no authored default").size(12));
-            if !reference {
-                if let Some(initial) = initial {
-                    out = out.push(
-                        button(text("Set literal default").size(11))
-                            .style(style::nav)
-                            .on_press(Message::FieldShape(
-                                path.into(),
-                                if collection {
-                                    json!([initial])
-                                } else {
-                                    initial
-                                },
-                            )),
-                    );
-                }
-                if collection && minimum == 0 {
-                    out = out.push(
-                        button(text("Set explicit empty collection").size(11))
-                            .style(style::nav)
-                            .on_press(Message::FieldShape(path.into(), json!([]))),
-                    );
-                }
-            }
-        } else {
-            out = out.push(
-                button(text("Clear default · make absent").size(11))
-                    .style(style::nav)
-                    .on_press(Message::FieldShape(path.into(), Value::Null)),
-            );
-            if let Some(values) = value.as_array() {
-                if values.is_empty() {
-                    out = out.push(text("Explicit empty collection []").size(12));
-                }
-                for (i, value) in values.iter().enumerate() {
-                    out = out
-                        .push(literal_editor(
-                            draft,
-                            project,
-                            value,
-                            &format!("{path}/{i}"),
-                            definition.as_ref(),
-                        ))
-                        .push(
-                            button(text("Remove value").size(10))
-                                .style(style::nav)
-                                .on_press(Message::FieldArray(path.into(), Some(i), 0)),
-                        );
-                }
-                if let Some(initial) = initial
-                    && !reference
-                {
-                    out = out.push(
-                        button(text("+ Add literal").size(11))
-                            .style(style::nav)
-                            .on_press(Message::FieldAppend(path.into(), initial)),
-                    );
-                }
-            } else {
-                out = out.push(literal_editor(
-                    draft,
-                    project,
-                    value,
-                    path,
-                    definition.as_ref(),
-                ));
-            }
-        }
-        return Some(out.into());
-    }
-    None
-}
-
-fn literal_editor<'a>(
-    draft: &'a Draft,
-    project: &'a Project,
-    value: &'a Value,
-    path: &str,
-    definition: Option<&DataTypeDefinition>,
-) -> View<'a, Message> {
-    if let Some(DataTypeDefinition::Enumeration { literals }) = definition {
-        let current = draft
-            .materialize()
-            .ok()
-            .and_then(|v| {
-                v.pointer(&format!("{path}/Enumeration"))
-                    .and_then(Value::as_str)
-                    .map(str::to_owned)
-            })
-            .or_else(|| {
-                value
-                    .get("Enumeration")
-                    .and_then(Value::as_str)
-                    .map(str::to_owned)
-            });
-        let mut choices = literals.clone();
-        if let Some(current) = &current
-            && !choices.contains(current)
-        {
-            choices.push(current.clone());
-        }
-        let path = path.to_owned();
-        let picker = pick_list(choices, current, move |s| {
-            Message::FieldShape(path.clone(), json!({"Enumeration": s}))
-        })
-        .text_size(12)
-        .padding(8)
-        .width(Fill);
-        return if value.get("Enumeration").is_none() {
-            column![text("Current default uses another literal type. Choose an enumeration literal or clear the default.").size(11).color(style::MUTED),picker].spacing(5).into()
-        } else {
-            picker.into()
-        };
-    }
-    let mut out = column![].spacing(5);
-    if let Some(fields) = value.as_object() {
-        for (tag, payload) in fields {
-            out = out.push(super::property(
-                draft,
-                project,
-                payload,
-                &format!("{path}/{tag}"),
-                &friendly(tag),
-                true,
-            ));
-        }
-    } else {
-        out = out.push(
-            text("Current literal requires review; clear it to choose a typed value.").size(11),
-        );
-    }
-    out.into()
-}
-
-fn message_value<'a>(
-    draft: &'a Draft,
-    project: &'a Project,
-    value: &'a Value,
-    path: &str,
-) -> View<'a, Message> {
-    let edited = draft.context_value();
-    let row = edited.pointer(path).unwrap_or(value).clone();
-    let current = serde_json::from_value::<MessageValue>(row.clone()).ok();
-    let owner = element(draft, project);
-    let context = owner
-        .as_ref()
-        .and_then(Element::shared)
-        .and_then(|body| match body {
-            SharedBody::Occurrence {
-                body:
-                    OccurrenceBody::Exchange {
-                        exchange: Some(id),
-                        message_kind,
-                        ..
-                    },
-                ..
-            } => project.relations.get(id).map(|r| (r, message_kind)),
-            _ => None,
-        });
-    let choices = context
-        .map(|(r, phase)| crate::data_values::choices(project, r, phase))
-        .unwrap_or_else(|| Ok(vec![]));
-    let mut out = column![text("Qualified carried field").size(11).color(style::MUTED)].spacing(6);
-    match choices {
-        Err(error) => out = out.push(text(error).size(11).color(style::MUTED)),
-        Ok(mut choices) => {
-            let current_key = current.as_ref().map(|v| crate::data_values::FieldPathKey {
-                path: v.path.clone(),
-                field: v.field,
-            });
-            let mut selected = current_key
-                .as_ref()
-                .and_then(|key| choices.iter().find(|c| &c.key == key))
-                .cloned()
-                .or_else(|| {
-                    context.and_then(|(r, phase)| {
-                        current_key
-                            .as_ref()
-                            .and_then(|key| crate::data_values::resolve(project, r, phase, key))
-                    })
-                });
-            if let Some(choice) = &selected
-                && !choices.iter().any(|c| c.key == choice.key)
-            {
-                choices.push(choice.clone());
-            }
-            if selected.is_none()
-                && let Some(key) = current_key.clone()
-                && !key.field.is_nil()
-            {
-                out = out.push(text("Current address needs review. Choose an explicit path to resolve a legacy, ambiguous or incompatible value.").size(11).color(style::MUTED));
-                let retained = crate::data_values::FieldPathChoice {
-                    label: format!(
-                        "Current address · {} / {}",
-                        key.path
-                            .iter()
-                            .map(|id| project.named(*id))
-                            .collect::<Vec<_>>()
-                            .join(" → "),
-                        project.named(key.field)
-                    ),
-                    key,
-                };
-                selected = Some(retained.clone());
-                choices.push(retained);
-            }
-            let owned = path.to_owned();
-            out = out.push(
-                pick_list(choices, selected, move |choice| {
-                    Message::FieldValuePath(owned.clone(), choice.key)
-                })
-                .placeholder("Choose a carried field path…")
-                .text_size(12)
-                .padding(8)
-                .width(Fill),
-            );
-        }
-    }
-    if let (Some((exchange, phase)), Some(current)) = (context, current) {
-        let key = crate::data_values::FieldPathKey {
-            path: current.path,
-            field: current.field,
-        };
-        if crate::data_values::resolve(project, exchange, phase, &key).is_some() {
-            if let Some(parent) = crate::data_values::parent(&key) {
-                out = out.push(
-                    button(text("Up to enclosing field").size(11))
-                        .style(style::nav)
-                        .on_press(Message::FieldValuePath(path.into(), parent)),
-                );
-            }
-            match crate::data_values::children(project, exchange, phase, &key) {
-                Ok(children) if !children.is_empty() => {
-                    let path = path.to_owned();
-                    out = out.push(
-                        pick_list(
-                            children,
-                            None::<crate::data_values::FieldPathChoice>,
-                            move |choice| Message::FieldValuePath(path.clone(), choice.key),
-                        )
-                        .placeholder("Choose a field inside this record…")
-                        .text_size(12)
-                        .padding(8)
-                        .width(Fill),
-                    );
-                }
-                Err(error) => out = out.push(text(error).size(11).color(style::MUTED)),
-                _ => {}
-            }
-        }
-    }
-    if let Some(expression) = value.get("expression") {
-        out = out.push(super::property(
-            draft,
-            project,
-            expression,
-            &format!("{path}/expression"),
-            "Value expression",
-            false,
-        ));
-    }
-    out.into()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn semantic_state(app: &crate::app::App) -> &crate::semantic_review::State {
-        let Some(crate::workflow::Workflow::Semantic(state)) = &app.workflow else {
-            panic!()
-        };
-        state
-    }
-    fn semantic_send(app: &mut crate::app::App, event: crate::semantic_review::Event) {
-        let _ = app.update(Message::Workflow(crate::workflow::Event::Semantic(event)));
-    }
-    fn semantic_decide(app: &mut crate::app::App, facet: FieldFacet, decision: SemanticDecision) {
-        use crate::semantic_review::Event;
-        semantic_send(app, Event::Select(FacetSelector::Field(facet)));
-        semantic_send(
-            app,
-            Event::Decide(FacetSelector::Field(facet), Some(decision)),
-        );
-    }
-    fn default_buttons(draft: &Draft, project: &Project, path: &str) -> usize {
-        use iced::advanced::widget::{Tree, tree::Tag};
-        let button: View<'_, Message> = button(text("Button")).into();
-        let tag = Tree::new(button.as_widget()).tag;
-        let view = property(draft, project, draft.value.pointer(path).unwrap(), path).unwrap();
-        fn count(tree: &Tree, tag: Tag) -> usize {
-            usize::from(tree.tag == tag)
-                + tree
-                    .children
-                    .iter()
-                    .map(|child| count(child, tag))
-                    .sum::<usize>()
-        }
-        count(&Tree::new(view.as_widget()), tag)
-    }
-
-    #[test]
-    fn semantic_reference_choices_follow_selected_mechanism_and_revert_on_keep() {
-        use crate::semantic_review::{Event, State};
-        let mut p = Project::empty();
-        let oa = p
-            .add_element(Kind::ExchangeItem, Layer::Oa, "Source", None)
-            .unwrap();
-        let sa = p
-            .add_element(Kind::ExchangeItem, Layer::Sa, "Target", None)
-            .unwrap();
-        let operation = p
-            .add_element(Kind::ExchangeItem, Layer::Sa, "Operation base", None)
-            .unwrap();
-        let flow = p
-            .add_element(Kind::ExchangeItem, Layer::Sa, "Flow base", None)
-            .unwrap();
-        for (id, next) in [
-            (oa, ExchangeMechanism::Operation),
-            (sa, ExchangeMechanism::Flow),
-            (operation, ExchangeMechanism::Operation),
-            (flow, ExchangeMechanism::Flow),
-        ] {
-            let Some(SharedBody::ExchangeItem { mechanism, .. }) =
-                p.elements.get_mut(&id).unwrap().shared_mut()
-            else {
-                panic!()
-            };
-            *mechanism = next;
-        }
-        let trace = Id::new_v4();
-        p.traces.insert(
-            trace,
-            Trace {
-                id: trace,
-                alias: "item_trace".into(),
-                name: "Review item".into(),
-                description: String::new(),
-                oa,
-                sa,
-                kind: TraceKind::Manual,
-                baseline: None,
-            },
-        );
-        let mut state = State::new(&p, oa).unwrap();
-        let facet = FacetSelector::ExchangeItem(ExchangeItemFacet::Mechanism);
-        let path = "/body/Sa/Shared/ExchangeItem/supertype";
-        let raw = state.draft.as_ref().unwrap().value.clone();
-        state.update(
-            &p,
-            Event::Decide(facet.clone(), Some(SemanticDecision::TakeSource)),
-        );
-        assert!(state.can_apply(), "{:?}", state.error);
-        let choices = reference_ids(state.draft.as_ref().unwrap(), &p, path);
-        assert!(choices.contains(&operation));
-        assert!(!choices.contains(&flow));
-        assert_eq!(state.draft.as_ref().unwrap().value, raw);
-        state.update(&p, Event::Decide(facet, Some(SemanticDecision::KeepTarget)));
-        let choices = reference_ids(state.draft.as_ref().unwrap(), &p, path);
-        assert!(!choices.contains(&operation));
-        assert!(choices.contains(&flow));
-    }
-
-    #[test]
-    fn independent_review_combined_take_type_informs_actual_default_form_in_both_directions() {
-        use crate::semantic_review::Event;
-        for reverse in [false, true] {
-            for decision in [SemanticDecision::TakeSource, SemanticDecision::Candidate] {
-                let mut p = Project::empty();
-                let mut pair = vec![];
-                for layer in [Layer::Oa, Layer::Sa] {
-                    let source = (layer == Layer::Oa) != reverse;
-                    let record = p
-                        .add_element(Kind::DataType, layer, "Record", None)
-                        .unwrap();
-                    *p.elements.get_mut(&record).unwrap().shared_mut().unwrap() =
-                        SharedBody::DataType {
-                            definition: DataTypeDefinition::Record { supertype: None },
-                            default: None,
-                            unit: String::new(),
-                        };
-                    let field = p
-                        .add_element(Kind::DataField, layer, "Payload", Some(record))
-                        .unwrap();
-                    *p.elements.get_mut(&field).unwrap().shared_mut().unwrap() =
-                        SharedBody::DataField {
-                            type_ref: if source {
-                                TypeRef::Boolean
-                            } else {
-                                TypeRef::Integer
-                            },
-                            minimum: 0,
-                            maximum: Some(1),
-                            unit: String::new(),
-                            direction: ParameterDirection::Unspecified,
-                            storage: FieldStorage::Value,
-                            default: None,
-                        };
-                    pair.push(field);
-                }
-                let trace = Id::new_v4();
-                p.traces.insert(
-                    trace,
-                    Trace {
-                        id: trace,
-                        alias: "payload_trace".into(),
-                        name: "Payload review".into(),
-                        description: String::new(),
-                        oa: pair[0],
-                        sa: pair[1],
-                        kind: TraceKind::Manual,
-                        baseline: None,
-                    },
-                );
-                let (source, target, layer) = if reverse {
-                    (pair[1], pair[0], "Oa")
-                } else {
-                    (pair[0], pair[1], "Sa")
-                };
-                let root = format!("/body/{layer}/Shared/DataField");
-                let default = format!("{root}/default");
-                let type_path = format!("{root}/type_ref");
-                let minimum = format!("{root}/minimum");
-                let mut app = crate::app::App::with_project(p);
-                let before = app.document.snapshot();
-                let _ = app.update(Message::StartSemanticReview(source));
-                // An unfinished candidate must not make the context fall back to
-                // the old target type, or contaminate a later Keep decision.
-                semantic_decide(&mut app, FieldFacet::Minimum, SemanticDecision::Candidate);
-                semantic_send(&mut app, Event::Input(minimum.clone(), "-".into()));
-                semantic_decide(&mut app, FieldFacet::Type, decision);
-                if decision == SemanticDecision::Candidate {
-                    semantic_send(
-                        &mut app,
-                        Event::Variant(type_path.clone(), json!("Boolean")),
-                    );
-                }
-                semantic_decide(&mut app, FieldFacet::Default, SemanticDecision::Candidate);
-                assert!(!semantic_state(&app).can_apply());
-                let draft = semantic_state(&app).draft.as_ref().unwrap();
-                assert!(matches!(
-                    element(draft, app.project()).unwrap().shared(),
-                    Some(SharedBody::DataField {
-                        type_ref: TypeRef::Boolean,
-                        ..
-                    })
-                ));
-                assert_eq!(draft.inputs[&minimum].raw, "-");
-                semantic_decide(&mut app, FieldFacet::Minimum, SemanticDecision::KeepTarget);
-                semantic_decide(&mut app, FieldFacet::Default, SemanticDecision::Candidate);
-                assert!(semantic_state(&app).can_apply());
-                let draft = semantic_state(&app).draft.as_ref().unwrap();
-                assert_eq!(default_buttons(draft, app.project(), &default), 2);
-                // These are the same element/definition/literal helpers used by
-                // the visible Set literal default and Add literal buttons.
-                let owner = element(draft, app.project()).unwrap();
-                let Some(SharedBody::DataField { type_ref, .. }) = owner.shared() else {
-                    panic!()
-                };
-                let initial = literal(&definition(app.project(), type_ref).unwrap()).unwrap();
-                assert_eq!(initial, json!({"Boolean": false}));
-                if decision == SemanticDecision::TakeSource {
-                    assert_eq!(draft.value.pointer(&type_path), Some(&json!("Integer")));
-                }
-                // Reverting the type changes the controls without changing its
-                // retained candidate. Storage constraints likewise read context.
-                semantic_decide(&mut app, FieldFacet::Type, SemanticDecision::KeepTarget);
-                assert!(matches!(
-                    element(semantic_state(&app).draft.as_ref().unwrap(), app.project())
-                        .unwrap()
-                        .shared(),
-                    Some(SharedBody::DataField {
-                        type_ref: TypeRef::Integer,
-                        ..
-                    })
-                ));
-                semantic_decide(&mut app, FieldFacet::Type, decision);
-                semantic_decide(&mut app, FieldFacet::Storage, SemanticDecision::Candidate);
-                semantic_send(
-                    &mut app,
-                    Event::Variant(format!("{root}/storage"), json!("Reference")),
-                );
-                assert_eq!(
-                    default_buttons(
-                        semantic_state(&app).draft.as_ref().unwrap(),
-                        app.project(),
-                        &default
-                    ),
-                    0
-                );
-                semantic_decide(&mut app, FieldFacet::Storage, SemanticDecision::KeepTarget);
-                assert_eq!(
-                    default_buttons(
-                        semantic_state(&app).draft.as_ref().unwrap(),
-                        app.project(),
-                        &default
-                    ),
-                    2
-                );
-                semantic_decide(&mut app, FieldFacet::Default, SemanticDecision::Candidate);
-                semantic_send(&mut app, Event::Shape(default, json!([initial])));
-                assert!(
-                    semantic_state(&app).can_apply(),
-                    "{:?}",
-                    semantic_state(&app).error
-                );
-                assert_eq!(app.document.bundle(), &before.bundle);
-                let _ = app.update(Message::Workflow(crate::workflow::Event::Apply));
-                assert!(
-                    matches!(app.project().elements[&target].shared(), Some(SharedBody::DataField {
-                    type_ref: TypeRef::Boolean, default: Some(values), minimum: 0, storage: FieldStorage::Value, ..
-                }) if values == &vec![DataValue::Boolean(false)])
-                );
-                let _ = app.update(Message::Undo);
-                assert_eq!(app.document.bundle(), &before.bundle);
-            }
-        }
-    }
-
-    #[test]
-    fn selecting_qualified_path_preserves_expression_typed_before_the_next_render() {
-        let (mut f, next) = crate::data_values::tests::recursive_payload();
-        if let Some(SharedBody::DataField { direction, .. }) = f
-            .project
-            .elements
-            .get_mut(&f.destination)
-            .unwrap()
-            .shared_mut()
-        {
-            *direction = ParameterDirection::InOut;
-        }
-        let call = f
-            .project
-            .add_element(Kind::Occurrence, Layer::Oa, "Call", Some(f.scenario))
-            .unwrap();
-        *f.project
-            .elements
-            .get_mut(&call)
-            .unwrap()
-            .shared_mut()
-            .unwrap() = SharedBody::Occurrence {
-            body: OccurrenceBody::Exchange {
-                exchange: Some(f.exchange),
-                sender: None,
-                receiver: None,
-                message_kind: MessageKind::Call,
-                reply_to: None,
-                values: vec![MessageValue {
-                    path: vec![f.origin],
-                    field: f.leaf,
-                    expression: "old".into(),
-                }],
-            },
-            precondition: String::new(),
-            postcondition: String::new(),
-        };
-        f.project
-            .elements
-            .get_mut(&f.scenario)
-            .unwrap()
-            .steps_mut()
-            .unwrap()
-            .push(call);
-        let mut app = crate::app::App::with_project(f.project.clone());
-        let path = "/body/Oa/Shared/Occurrence/body/Exchange/values/0";
-        let _ = app.update(Message::Select(call));
-        let _ = app.update(Message::Field(
-            format!("{path}/expression"),
-            "newly typed".into(),
-        ));
-        let _ = app.update(Message::FieldValuePath(
-            path.into(),
-            crate::data_values::FieldPathKey {
-                path: vec![f.destination],
-                field: f.leaf,
-            },
-        ));
-        let _ = app.update(Message::Apply);
-        let Some(SharedBody::Occurrence {
-            body: OccurrenceBody::Exchange { values, .. },
-            ..
-        }) = app.project().elements[&call].shared()
-        else {
-            panic!()
-        };
-        assert_eq!(
-            values,
-            &vec![MessageValue {
-                path: vec![f.destination],
-                field: f.leaf,
-                expression: "newly typed".into()
-            }],
-            "{}",
-            app.status
-        );
-        let _ = app.update(Message::Undo);
-        assert_eq!(app.project(), &f.project);
-        let nested = crate::data_values::children(
-            app.project(),
-            &app.project().relations[&f.exchange],
-            &MessageKind::Call,
-            &crate::data_values::FieldPathKey {
-                path: vec![f.origin],
-                field: next,
-            },
-        )
-        .unwrap()
-        .into_iter()
-        .find(|c| c.key.field == f.leaf)
-        .unwrap();
-        let _ = app.update(Message::Select(call));
-        let _ = app.update(Message::FieldValuePath(path.into(), nested.key.clone()));
-        let _ = app.update(Message::Apply);
-        let Some(SharedBody::Occurrence {
-            body: OccurrenceBody::Exchange { values, .. },
-            ..
-        }) = app.project().elements[&call].shared()
-        else {
-            panic!()
-        };
-        assert_eq!(values[0].path, vec![f.origin, next], "{}", app.status);
-        assert!(
-            crate::data_values::resolve(
-                app.project(),
-                &app.project().relations[&f.exchange],
-                &MessageKind::Call,
-                &nested.key
-            )
-            .is_some()
-        );
-        let _ = super::super::view(app.draft.as_ref().unwrap(), app.project());
-    }
-
-    #[test]
-    fn numeric_bound_drafts_keep_partial_and_full_precision_values_out_of_accepted_state() {
-        let mut p = Project::empty();
-        let id = p
-            .add_element(Kind::DataType, Layer::Oa, "Counter", None)
-            .unwrap();
-        let mut draft = Draft::from_project(&p, id).unwrap();
-        let definition = "/body/Oa/Shared/DataType/definition";
-        draft
-            .shape(
-                definition,
-                json!({"Integer":{"minimum":null,"maximum":i64::MAX}}),
-            )
-            .unwrap();
-        let maximum = format!("{definition}/Integer/maximum");
-        draft.input(&maximum, "-".into());
-        assert!(draft.command().is_err());
-        assert!(draft.shape(&maximum, Value::Null).is_err());
-        assert_eq!(draft.inputs[&maximum].raw, "-");
-        draft.input(&maximum, "9223372036854775808".into());
-        assert!(draft.command().is_err());
-        draft.input(&maximum, i64::MAX.to_string());
-        draft
-            .shape(
-                "/body/Oa/Shared/DataType/default",
-                json!({"Integer":i64::MAX}),
-            )
-            .unwrap();
-        let accepted = execute_batch(&p, &[draft.command().unwrap()]).unwrap();
-        assert!(matches!(
-            accepted.elements[&id].shared(),
-            Some(SharedBody::DataType {
-                definition: DataTypeDefinition::Integer {
-                    maximum: Some(i64::MAX),
-                    ..
-                },
-                default: Some(DataValue::Integer(i64::MAX)),
-                ..
-            })
-        ));
-        draft.input(&maximum, "10".into());
-        assert!(execute_batch(&accepted, &[draft.command().unwrap()]).is_err());
-        assert_eq!(draft.inputs[&maximum].raw, "10");
-    }
-
-    #[test]
-    fn defaults_distinguish_absent_empty_and_typed_literals_with_escaped_unicode() {
-        let mut p = Project::empty();
-        let item = p
-            .add_element(Kind::ExchangeItem, Layer::Oa, "Payload", None)
-            .unwrap();
-        let id = p
-            .add_element(Kind::DataField, Layer::Oa, "Optional names", Some(item))
-            .unwrap();
-        let mut draft = Draft::from_project(&p, id).unwrap();
-        let root = "/body/Oa/Shared/DataField";
-        draft.shape(&format!("{root}/minimum"), json!(0)).unwrap();
-        draft
-            .shape(&format!("{root}/maximum"), Value::Null)
-            .unwrap();
-        draft.shape(&format!("{root}/default"), json!([])).unwrap();
-        let empty = execute_batch(&p, &[draft.command().unwrap()]).unwrap();
-        assert!(
-            matches!(empty.elements[&id].shared(),Some(SharedBody::DataField {default:Some(v),..}) if v.is_empty())
-        );
-        draft
-            .shape(&format!("{root}/default"), Value::Null)
-            .unwrap();
-        let absent = execute_batch(&empty, &[draft.command().unwrap()]).unwrap();
-        assert!(matches!(
-            absent.elements[&id].shared(),
-            Some(SharedBody::DataField { default: None, .. })
-        ));
-        draft
-            .shape(&format!("{root}/default"), json!([{"String":"é🙂\n"}]))
-            .unwrap();
-        draft.input(&format!("{root}/default/0/String"), "é🙂\n".into());
-        draft
-            .append(&format!("{root}/default"), json!({"String":"next"}))
-            .unwrap();
-        assert_eq!(
-            draft
-                .materialize()
-                .unwrap()
-                .pointer(&format!("{root}/default/0/String")),
-            Some(&json!("é🙂\n"))
-        );
-        draft.array(&format!("{root}/default"), Some(1), 0).unwrap();
-        draft.set_exact(true).unwrap();
-        let saved = execute_batch(&absent, &[draft.command().unwrap()]).unwrap();
-        assert!(
-            matches!(saved.elements[&id].shared(),Some(SharedBody::DataField {default:Some(v),..}) if v == &vec![DataValue::String("é🙂\n".into())])
-        );
-        let _ = super::super::view(&draft, &saved);
-        draft
-            .shape(&format!("{root}/storage"), json!("Reference"))
-            .unwrap();
-        assert!(execute_batch(&saved, &[draft.command().unwrap()]).is_err());
-    }
-
-    #[test]
-    fn supertype_picker_excludes_descendants_and_keeps_original_inherited_field_identity() {
-        let mut p = Project::empty();
-        let base = p
-            .add_element(Kind::DataType, Layer::Oa, "Base", None)
-            .unwrap();
-        let child = p
-            .add_element(Kind::DataType, Layer::Oa, "Child", None)
-            .unwrap();
-        for (id, supertype) in [(base, None), (child, Some(base))] {
-            *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::DataType {
-                definition: DataTypeDefinition::Record { supertype },
-                default: None,
-                unit: String::new(),
-            };
-        }
-        let field = p
-            .add_element(Kind::DataField, Layer::Oa, "Owned by base", Some(base))
-            .unwrap();
-        let draft = Draft::from_project(&p, base).unwrap();
-        let path = "/body/Oa/Shared/DataType/definition/Record/supertype";
-        assert!(!reference_ids(&draft, &p, path).contains(&child));
-        let child_draft = Draft::from_project(&p, child).unwrap();
-        assert!(reference_ids(&child_draft, &p, path).contains(&base));
-        assert_eq!(data::effective_fields(&p, child)[0].id, field);
-        assert_eq!(p.elements[&field].parent, Some(base));
-    }
-}

crates/oa-desktop/src/forms/port_fields.rs

@@ -42,14 +42,10 @@ pub(super) fn variants(
     _value: &Value,
 ) -> Option<Vec<(String, Value)>> {
     if path.ends_with("/Port/contract") {
-        let current = draft.context_value();
+        let current = draft.materialize().unwrap_or_else(|_| draft.value.clone());
         let sa = current.pointer("/body/Sa").is_some();
         if !sa {
-            return Some(if draft.semantic_groups {
-                vec![("Legacy generic port".into(), json!("Legacy"))]
-            } else {
-                vec![]
-            });
+            return Some(vec![]);
         }
         let owner = current
             .get("parent")
@@ -73,9 +69,6 @@ pub(super) fn variants(
                 json!({"Component":{"kind":"Standard","orientation":"Unset"}}),
             ));
         }
-        if draft.semantic_groups {
-            choices.push(("Legacy generic port".into(), json!("Legacy")));
-        }
         return Some(choices);
     }
     if path.ends_with("/Port/contract/Component/kind") {
@@ -87,7 +80,7 @@ pub(super) fn variants(
         );
     }
     if path.ends_with("/Port/contract/Component/orientation") {
-        let current = draft.context_value();
+        let current = draft.materialize().unwrap_or_else(|_| draft.value.clone());
         let kind_path = path.strip_suffix("orientation").unwrap().to_owned() + "kind";
         let orientations: &[&str] =
             if current.pointer(&kind_path).and_then(Value::as_str) == Some("Standard") {
@@ -151,7 +144,13 @@ fn component_items_fit(project: &Project, port: Id, items: &[Id]) -> bool {
     }
     let declared: Vec<_> = interfaces
         .iter()
-        .flat_map(|id| data::interface_items(project, *id))
+        .filter_map(|id| project.elements.get(id))
+        .filter_map(|e| match e.shared() {
+            Some(SharedBody::Interface { items }) => Some(items),
+            _ => None,
+        })
+        .flatten()
+        .copied()
         .collect();
     items_satisfy(project, items, &declared)
 }
@@ -715,12 +714,8 @@ mod tests {
             interface,
         );
         assert!(reference_ids(&draft, &project, target).is_empty());
-        project.relate(
-            RelationKind::InterfaceItemAllocation,
-            "Allocated item",
-            interface,
-            item,
-        );
+        project.elements.get_mut(&interface).unwrap().body =
+            ElementBody::shared_in(Layer::Sa, SharedBody::Interface { items: vec![item] });
         assert_eq!(reference_ids(&draft, &project, target), vec![output]);
     }
 

crates/oa-desktop/src/guide.rs

@@ -369,7 +369,7 @@ fn article(topic: Topic) -> Article {
                             &[
                                 "Create the source and target activities/functions in one perspective. Give each an engineering name and allocate leaf work to its responsible participant.",
                                 "Choose Interaction or Functional exchange in the diagram palette. Click the source, then a highlighted compatible target, or drag between them. Functional exchanges connect output ports to input ports; function cards create or reuse real ports in the same transaction. Middle-button drag pans while keeping the source; arrow keys also pan when the drawing canvas has focus. Click empty space to restart, or Escape to cancel.",
-                                "Create an Exchange item under Data & interfaces. Choose its nature (Information, Material or Energy) and its mechanism (Flow, Event, Operation or Shared data). Describe the payload independently of the connection.",
+                                "Create an Exchange item under Data & interfaces. Choose its kind (Information, Material, Energy or Event) and describe its payload.",
                                 "Select the exchange in Model explorer or the diagram. Edit its properties to reference the appropriate exchange items and available ports; Apply changes validates the complete record.",
                                 "Choose Boundary exchange and connect compatible component ports. Flow goes from Out to In; Standard is unoriented. Select / move returns to arranging. Exchange allocation associates a boundary exchange with the functional exchange it carries.",
                             ],
@@ -380,7 +380,7 @@ fn article(topic: Topic) -> Article {
                         ),
                         explain(
                             "Use engineering payloads",
-                            "Choose Information for data such as a distress report, Energy for delivered power and Material for a transferred substance. Mechanism separately describes how it is exchanged: an Event is a notification, an Operation has parameters, and a Flow carries values or a physical quantity. Data types and fields make payloads precise. Artifact links can point to interface-control documents.",
+                            "Choose Information for data such as a distress report, Energy for delivered power, Material for a transferred substance and Event for a notification. Data types and fields can make structured payloads precise. URI artifact links can point to detailed interface-control documents.",
                         ),
                     ],
                     related: &[
@@ -510,34 +510,17 @@ fn article(topic: Topic) -> Article {
             const {
                 Article {
                     summary: "Define exchanged payloads independently of the ports and participants that carry them. Reuse the same data definitions in related exchanges.",
-                    keywords: "data interface port direction input output inout return contract provision requirement exchange item enum enumeration record primitive field value type multiplicity minimum maximum bounds default unit specialization inheritance association storage reference recursive path transmission acquisition protocol",
+                    keywords: "data interface port direction input output inout contract provision requirement exchange item enum enumeration record primitive field value type multiplicity minimum maximum",
                     sections: &[
                         walkthrough(
                             "Define a reusable payload",
                             &[
-                                "Open Data & interfaces and create an Exchange item. Choose Information, Material or Energy for nature; choose Flow, Event, Operation or Shared data for mechanism. Keep Unspecified when the engineering decision is still open.",
-                                "Create a Data type for a reusable definition. Choose Boolean, Integer, Real, String, Enumeration or Record. Numeric bounds are inclusive; String bounds count Unicode characters. A typed default must satisfy those bounds or enumeration literals. Units annotate quantities without converting them.",
-                                "Create fields within an Exchange item or Record type. Set Value type, minimum/maximum count, unit and optional default. A default can be absent, explicitly empty when minimum is zero, or a list of typed scalar values. A type default describes one element; it does not create a required collection.",
+                                "Open Data & interfaces and create an Exchange item. Select Information, Material, Energy or Event to describe the nature of the exchange.",
+                                "Create a Data type where the payload needs a named definition. Choose its Data type definition and edit the corresponding values in Properties.",
+                                "For structured definitions, create Data fields under a legal Data type or Exchange item owner. Set Value type and the minimum/maximum count as required by the contract.",
                                 "Select the exchange and reference the payload items. Apply changes and check the result in Model checks.",
                             ],
                         ),
-                        explain(
-                            "Operation parameters and message values",
-                            "An Operation's direct fields are parameters. In and InOut supply call values; Out, InOut and Return supply reply values, from the provider's perspective. There is at most one Return parameter. Qualified paths distinguish origin.latitude from destination.latitude when both use the same Coordinate record. Nested fields inherit the parameter direction. Message expressions are annotations, not evaluated values.",
-                        ),
-                        explain(
-                            "Reuse, ownership and references",
-                            "A Record or Exchange item can specialize one compatible base. Inherited fields keep their original owner and identity; edit the base to change them. Value fields compose a payload. Reference fields refer to separately identified Record objects and stop payload expansion. Optional recursive values and reference cycles are valid; a mandatory value cycle warns that no finite complete value exists. Data associations describe named reference ends, multiplicities and navigation between Record types without creating contained fields.",
-                        ),
-                        walkthrough(
-                            "Allocate an item to interfaces",
-                            &[
-                                "Create an Interface and allocate an Exchange item. Select its allocation row to edit transmission, acquisition and order; Open item navigates to the shared payload definition.",
-                                "Two interfaces may allocate the same item with different protocols. Attach CAD, code or document evidence to the allocation when it concerns that particular contract.",
-                                "Removing an allocation keeps the shared item and other allocations. If a live boundary depends on it, first revise that boundary contract. Undo restores an accepted removal.",
-                                "An Interface may specialize one base and inherit its allocations. Duplicate allocation of an already inherited item is rejected. A specialized item satisfies its base contract; a base item does not satisfy a more specific contract.",
-                            ],
-                        ),
                         walkthrough(
                             "Connect participant boundaries",
                             &[
@@ -740,7 +723,7 @@ fn article(topic: Topic) -> Article {
                         ),
                         explain(
                             "Open and migration",
-                            "Open validates a complete candidate before replacing the project. Versions 1, 2 and 3 migrate explicitly to version 4; Model checks shows preserved ports, supplied data defaults, generated interface allocations and unresolved message paths. Old Event items become Information notifications; unknown physical mechanisms remain Unspecified. Source3 upgrades retain files, includes, nested ownership and comments. Opening does not overwrite the original: use Save as if it must remain in its older format. Invalid input leaves the accepted project unchanged.",
+                            "Open reads and validates a complete candidate before replacing the current project. Supported legacy files are migrated explicitly; save the resulting current format under a new name if the legacy original must remain available. Unsupported or invalid input does not replace the accepted project.",
                         ),
                     ],
                     related: &[Topic::Source, Topic::Recovery, Topic::Artifacts],

crates/oa-desktop/src/main.rs

@@ -4,8 +4,6 @@ mod behavior;
 mod connection_edit;
 mod connection_tool;
 mod context_menu;
-mod data_values;
-mod data_view;
 mod diagram;
 mod document;
 mod explorer;
@@ -19,7 +17,6 @@ mod port_edit;
 mod port_preview;
 mod port_workflow;
 mod route_edit;
-mod semantic_review;
 mod source_navigation;
 mod source_tree;
 mod source_workspace;

crates/oa-desktop/src/model_menu.rs

@@ -415,15 +415,10 @@ pub fn popup(app: &App) -> Option<Menu<Message>> {
         if p.layer_of(id).is_some() {
             entries.push(item("Create relationship…", Message::AddRelation, true));
             entries.push(item(
-                "Create counterpart / review prose…",
+                "Create / update counterpart…",
                 Message::StartTransition,
                 true,
             ));
-            entries.push(item(
-                "Review semantics…",
-                Message::StartSemanticReview(id),
-                p.traces.values().any(|t| t.oa == id || t.sa == id),
-            ));
         }
         entries.push(item(
             "Attach artifact reference…",

crates/oa-desktop/src/port_preview.rs

@@ -157,9 +157,12 @@ pub fn port_context_rows(project: &Project, port: Id) -> Vec<String> {
     }
     if let Some(legacy) = legacy {
         rows.push(legacy_line(&context, legacy));
-        if let Some(interface) = legacy.interface {
-            for item in data::interface_items(project, interface) {
-                origins.entry(item).or_default().push(format!(
+        if let Some(interface) = legacy.interface
+            && let Some(SharedBody::Interface { items }) =
+                context.element(interface).and_then(Element::shared)
+        {
+            for item in items {
+                origins.entry(*item).or_default().push(format!(
                     "preserved interface {} (suggestion only; not an active typed contract)",
                     context.label(interface)
                 ));
@@ -708,17 +711,11 @@ mod tests {
         let (other_fe, commands) = exchange(&mut project, source, target, vec![second]);
         project = execute_batch(&project, &commands).unwrap();
         let interface = add(&mut project, Kind::Interface, "Incident service");
-        project.relate(
-            RelationKind::InterfaceItemAllocation,
-            "First item",
-            interface,
-            first,
-        );
-        project.relate(
-            RelationKind::InterfaceItemAllocation,
-            "Second item",
-            interface,
-            second,
+        project.elements.get_mut(&interface).unwrap().body = ElementBody::shared_in(
+            Layer::Sa,
+            SharedBody::Interface {
+                items: vec![first, second],
+            },
         );
         let connection = &project.relations[&boundary];
         let (a, b) = (connection.source(), connection.target());
@@ -793,12 +790,8 @@ mod tests {
             ..
         } = fixture();
         let interface = add(&mut project, Kind::Interface, "Preserved contract");
-        project.relate(
-            RelationKind::InterfaceItemAllocation,
-            "Allocated item",
-            interface,
-            first,
-        );
+        project.elements.get_mut(&interface).unwrap().body =
+            ElementBody::shared_in(Layer::Sa, SharedBody::Interface { items: vec![first] });
         let legacy = port(
             &mut project,
             source,

crates/oa-desktop/src/port_workflow.rs

@@ -168,9 +168,12 @@ impl State {
                 _ => {}
             }
         }
-        if let Some(interface) = old.and_then(|old| old.interface) {
-            let items = data::interface_items(p, interface);
-            incoming.extend(items.iter().copied());
+        if let Some(SharedBody::Interface { items }) = old
+            .and_then(|old| old.interface)
+            .and_then(|id| p.elements.get(&id))
+            .and_then(|e| e.shared())
+        {
+            incoming.extend(items);
             outgoing.extend(items);
         }
         for r in p.relations.values() {

crates/oa-desktop/src/semantic_review.rs

@@ -1,797 +0,0 @@
-//! Deliberate semantic review of one existing trace; drafts never mutate the model.
-use crate::{
-    app::{Choice, Message},
-    forms::Draft,
-};
-use iced::widget::text_editor;
-use oa_core::{transitions::*, *};
-use serde_json::Value;
-use std::collections::{BTreeMap, BTreeSet};
-
-mod constructors;
-mod history;
-mod keyed;
-mod message_kind;
-mod scalar;
-mod view;
-pub(crate) use view::summary;
-#[cfg(test)]
-mod constructor_tests;
-#[cfg(test)]
-mod keyed_tests;
-#[cfg(test)]
-mod message_kind_tests;
-#[cfg(test)]
-mod tests;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Tab {
-    Facts,
-    References,
-    Members,
-    History,
-    Impacts,
-}
-
-#[derive(Debug, Clone)]
-pub enum Event {
-    Trace(Choice),
-    Direction(TransitionDirection),
-    Select(FacetSelector),
-    Decide(FacetSelector, Option<SemanticDecision>),
-    Input(String, String),
-    Text(String, text_editor::Action),
-    Shape(String, Value),
-    Variant(String, Value),
-    Array(String, Option<usize>, i32),
-    Append(String, Value),
-    ValuePath(String, crate::data_values::FieldPathKey),
-    Tab(Tab),
-    ShowUnchanged(bool),
-    ReferenceOa(Choice),
-    ReferenceSa(Choice),
-    ReferenceSearch(String),
-    AddReference,
-    RemoveReference(Id),
-    AcceptImpact(usize, bool),
-    Preview,
-    Reset(FacetSelector, bool),
-    Presence(FacetSelector, bool),
-    MemberFamily(keyed::Family),
-    MemberOa(Option<Choice>),
-    MemberSa(Option<Choice>),
-    Literal(String),
-    LiteralSide(Layer, bool),
-    EditPair(FacetSelector),
-    StageMember,
-    DropStaged(FacetSelector),
-}
-
-pub struct State {
-    pub anchor: Id,
-    pub trace: Option<Id>,
-    pub direction: TransitionDirection,
-    pub facts: Vec<FacetDrift>,
-    pub selected: Option<FacetSelector>,
-    pub decisions: BTreeMap<FacetSelector, SemanticDecision>,
-    pub references: BTreeMap<Id, Id>,
-    pub resets: BTreeSet<FacetSelector>,
-    pub staged: BTreeSet<FacetSelector>,
-    pub presence: BTreeMap<FacetSelector, bool>,
-    pub member_family: keyed::Family,
-    pub member_oa: Option<Choice>,
-    pub member_sa: Option<Choice>,
-    pub literal: String,
-    pub literal_oa: bool,
-    pub literal_sa: bool,
-    pub draft: Option<Draft>,
-    // Each closed constructor has an independent draft, including nested kinds.
-    // Scalar and sibling drafts survive decision and constructor changes.
-    pub group_drafts: BTreeMap<FacetSelector, Draft>,
-    pub plan: Option<SemanticTransitionPlan>,
-    pub proposed: Option<Project>,
-    pub error: Option<String>,
-    pub tab: Tab,
-    pub show_unchanged: bool,
-    pub reference_oa: Option<Choice>,
-    pub reference_sa: Option<Choice>,
-    pub reference_search: String,
-    accepted_impacts: Vec<SemanticImpact>,
-}
-
-impl State {
-    pub fn new(project: &Project, selected: Id) -> Result<Self, String> {
-        let explicit = project.traces.get(&selected);
-        let anchor = explicit.map_or(selected, |trace| trace.oa);
-        let layer = project
-            .layer_of(anchor)
-            .ok_or("Select an OA or SA object, relationship or trace to review.")?;
-        let choices: Vec<_> = project
-            .traces
-            .values()
-            .filter(|t| t.oa == anchor || t.sa == anchor)
-            .collect();
-        if choices.is_empty() {
-            return Err("This object has no trace. Create a counterpart or link existing counterparts first.".into());
-        }
-        let trace = explicit
-            .map(|t| t.id)
-            .or_else(|| (choices.len() == 1).then(|| choices[0].id));
-        let mut state = Self {
-            anchor,
-            trace,
-            direction: if layer == Layer::Oa {
-                TransitionDirection::OaToSa
-            } else {
-                TransitionDirection::SaToOa
-            },
-            facts: vec![],
-            selected: None,
-            decisions: BTreeMap::new(),
-            references: BTreeMap::new(),
-            resets: BTreeSet::new(),
-            staged: BTreeSet::new(),
-            presence: BTreeMap::new(),
-            member_family: keyed::Family::Literal,
-            member_oa: None,
-            member_sa: None,
-            literal: String::new(),
-            literal_oa: true,
-            literal_sa: true,
-            draft: None,
-            group_drafts: BTreeMap::new(),
-            plan: None,
-            proposed: None,
-            error: None,
-            tab: Tab::Facts,
-            show_unchanged: false,
-            reference_oa: None,
-            reference_sa: None,
-            reference_search: String::new(),
-            accepted_impacts: vec![],
-        };
-        state.load_trace(project);
-        Ok(state)
-    }
-
-    pub fn target(&self, project: &Project) -> Option<Id> {
-        let trace = project.traces.get(&self.trace?)?;
-        Some(if self.direction == TransitionDirection::OaToSa {
-            trace.sa
-        } else {
-            trace.oa
-        })
-    }
-
-    fn load_trace(&mut self, project: &Project) {
-        self.facts.clear();
-        self.decisions.clear();
-        self.resets.clear();
-        self.staged.clear();
-        self.presence.clear();
-        self.member_oa = None;
-        self.member_sa = None;
-        self.literal.clear();
-        self.literal_oa = true;
-        self.literal_sa = true;
-        self.selected = None;
-        self.accepted_impacts.clear();
-        self.references.clear();
-        self.draft = self
-            .target(project)
-            .and_then(|id| Draft::from_project(project, id));
-        self.group_drafts.clear();
-        if let Some(trace) = self.trace.and_then(|id| project.traces.get(&id)) {
-            for facet in constructors::selectors() {
-                if constructors::available(project, trace, &facet)
-                    && let Some(mut draft) = self
-                        .target(project)
-                        .and_then(|id| Draft::from_project(project, id))
-                {
-                    draft.semantic_groups = true;
-                    self.group_drafts.insert(facet, draft);
-                }
-            }
-        }
-        if let Some(trace) = self.trace.and_then(|id| project.traces.get(&id)) {
-            self.references.insert(trace.oa, trace.sa);
-        }
-        self.member_family = self
-            .member_families(project)
-            .first()
-            .copied()
-            .unwrap_or(keyed::Family::Literal);
-        self.refresh(project);
-    }
-
-    pub fn update(&mut self, project: &Project, event: Event) {
-        let mut replan = true;
-        let result = match event {
-            Event::Trace(choice) => {
-                if !project
-                    .traces
-                    .get(&choice.id)
-                    .is_some_and(|t| t.oa == self.anchor || t.sa == self.anchor)
-                {
-                    Err("Choose one of this object's existing traces.".into())
-                } else {
-                    self.trace = Some(choice.id);
-                    self.load_trace(project);
-                    return;
-                }
-            }
-            Event::Direction(direction) => {
-                self.direction = direction;
-                self.load_trace(project);
-                return;
-            }
-            Event::Select(facet) => {
-                self.selected = Some(facet);
-                replan = false;
-                Ok(())
-            }
-            Event::Decide(facet, decision) => {
-                if let Some(decision) = decision {
-                    if !self.editable(project, &facet)
-                        && !(decision == SemanticDecision::KeepTarget
-                            && self.can_acknowledge_constructor(project, &facet))
-                    {
-                        Err("This fact needs the structured review workflow; its history remains unchanged.".into())
-                    } else {
-                        if keyed::supported(&facet) {
-                            let target_presence = self
-                                .effective_trace(project)
-                                .and_then(|t| capture_facet(project, t.oa, t.sa, &facet).ok())
-                                .and_then(|f| scalar::value(&f, self.direction.target_layer()))
-                                .and_then(|v| v.as_bool())
-                                .unwrap_or(false);
-                            self.presence
-                                .entry(facet.clone())
-                                .or_insert(target_presence);
-                        }
-                        self.decisions.insert(facet, decision);
-                        Ok(())
-                    }
-                } else {
-                    self.decisions.remove(&facet);
-                    Ok(())
-                }
-            }
-            Event::Input(path, value) => self.edit(project, &path, |d| {
-                d.input(&path, value);
-                Ok(())
-            }),
-            Event::Text(path, action) => self.edit(project, &path, |d| {
-                d.edit_text(&path, action);
-                Ok(())
-            }),
-            Event::Shape(path, value) => {
-                self.edit(project, &path, |d| d.shape_scoped(&path, value))
-            }
-            Event::Variant(path, value) => {
-                self.edit(project, &path, |d| d.variant_scoped(&path, value))
-            }
-            Event::Array(path, index, direction) => {
-                self.edit(project, &path, |d| d.array_scoped(&path, index, direction))
-            }
-            Event::Append(path, value) => {
-                self.edit(project, &path, |d| d.append_scoped(&path, value))
-            }
-            Event::ValuePath(path, key) => {
-                self.edit(project, &path, |d| d.value_path_scoped(&path, key))
-            }
-            Event::Tab(tab) => {
-                self.tab = tab;
-                replan = false;
-                Ok(())
-            }
-            Event::ShowUnchanged(show) => {
-                self.show_unchanged = show;
-                replan = false;
-                Ok(())
-            }
-            Event::ReferenceOa(choice) => {
-                self.reference_oa = Some(choice);
-                replan = false;
-                Ok(())
-            }
-            Event::ReferenceSa(choice) => {
-                self.reference_sa = Some(choice);
-                replan = false;
-                Ok(())
-            }
-            Event::ReferenceSearch(value) => {
-                self.reference_search = value;
-                replan = false;
-                Ok(())
-            }
-            Event::AddReference => match (&self.reference_oa, &self.reference_sa) {
-                (Some(oa), Some(sa)) => {
-                    self.references.insert(oa.id, sa.id);
-                    Ok(())
-                }
-                _ => Err("Choose both an Operational and a System reference.".into()),
-            },
-            Event::RemoveReference(id) => {
-                self.references.remove(&id);
-                Ok(())
-            }
-            Event::AcceptImpact(index, accepted) => {
-                if let Some(impact) = self
-                    .plan
-                    .as_ref()
-                    .and_then(|p| p.impacts.get(index))
-                    .cloned()
-                {
-                    self.accepted_impacts.retain(|i| i.object != impact.object);
-                    if accepted {
-                        self.accepted_impacts.push(impact);
-                    }
-                }
-                self.refresh(project);
-                return;
-            }
-            Event::Preview => Ok(()),
-            Event::Reset(facet, reset) => self.reset_history(project, facet, reset),
-            Event::Presence(facet, present) => {
-                if keyed::supported(&facet)
-                    && self.decisions.get(&facet) == Some(&SemanticDecision::Candidate)
-                {
-                    self.presence.insert(facet, present);
-                    Ok(())
-                } else {
-                    Err("Choose Set final value for this member before editing presence.".into())
-                }
-            }
-            Event::MemberFamily(family) => {
-                self.member_family = family;
-                replan = false;
-                Ok(())
-            }
-            Event::MemberOa(choice) => {
-                self.member_oa = choice;
-                replan = false;
-                Ok(())
-            }
-            Event::MemberSa(choice) => {
-                self.member_sa = choice;
-                replan = false;
-                Ok(())
-            }
-            Event::Literal(value) => {
-                self.literal = value;
-                replan = false;
-                Ok(())
-            }
-            Event::LiteralSide(layer, present) => {
-                if layer == Layer::Oa {
-                    self.literal_oa = present;
-                } else {
-                    self.literal_sa = present;
-                }
-                replan = false;
-                Ok(())
-            }
-            Event::EditPair(facet) => {
-                replan = false;
-                self.edit_pair(project, facet)
-            }
-            Event::StageMember => self.stage_member(project),
-            Event::DropStaged(facet) => {
-                if self.staged.remove(&facet) {
-                    self.decisions.remove(&facet);
-                }
-                Ok(())
-            }
-        };
-        if let Err(error) = result {
-            self.error = Some(error);
-            self.plan = None;
-            self.proposed = None;
-            return;
-        }
-        if replan {
-            self.accepted_impacts.clear();
-            self.refresh(project);
-        }
-    }
-
-    fn edit(
-        &mut self,
-        project: &Project,
-        path: &str,
-        action: impl FnOnce(&mut Draft) -> Result<(), String>,
-    ) -> Result<(), String> {
-        let facet = self.selected.as_ref().ok_or("Choose a property first.")?;
-        if self.decisions.get(facet) != Some(&SemanticDecision::Candidate) {
-            return Err("Choose Set final value before editing this property.".into());
-        }
-        let roots = self
-            .target(project)
-            .and_then(|id| constructors::roots(project, id, facet))
-            .ok_or("Selected property is unavailable.")?;
-        if !roots
-            .iter()
-            .any(|root| path == root || path.starts_with(&format!("{root}/")))
-        {
-            return Err("Only the selected review property can change in this draft.".into());
-        }
-        let draft = if scalar::grouped(facet) {
-            self.group_drafts.get_mut(facet)
-        } else {
-            self.draft.as_mut()
-        }
-        .ok_or("Choose an existing target.")?;
-        // The scoped view sends only the selected property or closed group roots.
-        // Protected identity and top-level body/perspective controls are never exposed.
-        if path == "/id" || path == "/alias" || path == "/body" || path == "/layer" {
-            return Err("Semantic candidates retain identity, alias and perspective.".into());
-        }
-        action(draft)
-    }
-
-    pub fn editable(&self, project: &Project, facet: &FacetSelector) -> bool {
-        if keyed::supported(facet) {
-            return self
-                .effective_trace(project)
-                .is_some_and(|trace| capture_facet(project, trace.oa, trace.sa, facet).is_ok());
-        }
-        self.target(project)
-            .and_then(|id| scalar::binding(project, id, facet))
-            .is_some()
-            && (!scalar::grouped(facet)
-                || (self.group_drafts.contains_key(facet)
-                    && self
-                        .trace
-                        .and_then(|id| project.traces.get(&id))
-                        .is_some_and(|trace| constructors::available(project, trace, facet))))
-    }
-
-    fn candidate_draft(&self, facet: &FacetSelector) -> Option<&Draft> {
-        if scalar::grouped(facet) {
-            self.group_drafts.get(facet)
-        } else {
-            self.draft.as_ref()
-        }
-    }
-
-    pub fn can_acknowledge_constructor(&self, project: &Project, facet: &FacetSelector) -> bool {
-        if !scalar::grouped(facet) {
-            return false;
-        }
-        let Some(trace) = self.effective_trace(project) else {
-            return false;
-        };
-        if trace
-            .baseline
-            .as_ref()
-            .and_then(|b| b.semantic.as_ref())
-            .is_some_and(|b| b.facets.iter().any(|f| f.selector() == *facet))
-        {
-            return false;
-        }
-        capture_facet(project, trace.oa, trace.sa, facet)
-            .ok()
-            .is_some_and(|current| {
-                scalar::value(&current, Layer::Oa).is_some()
-                    && scalar::observation(&current, Layer::Oa)
-                        == scalar::observation(&current, Layer::Sa)
-            })
-    }
-
-    fn request(&self, project: &Project) -> Result<SemanticTransitionRequest, String> {
-        let trace = self
-            .trace
-            .and_then(|id| project.traces.get(&id))
-            .ok_or("Choose the trace whose review history you want to update.")?;
-        let (source, target) = if self.direction == TransitionDirection::OaToSa {
-            (trace.oa, trace.sa)
-        } else {
-            (trace.sa, trace.oa)
-        };
-        let mut transition = TransitionRequest::new(self.direction, vec![source]);
-        transition.mappings.push(TransitionMapping {
-            source,
-            target: Some(target),
-            target_kind: None,
-        });
-        let mut request = SemanticTransitionRequest::new(transition);
-        request.traces.insert(source, trace.id);
-        request.references = self.references.clone();
-        request.reviews.push(SemanticReviewRequest {
-            source,
-            resolutions: self
-                .decisions
-                .iter()
-                .map(|(facet, decision)| FacetResolution {
-                    facet: facet.clone(),
-                    decision: *decision,
-                })
-                .collect(),
-            reset: self.resets.iter().cloned().collect(),
-        });
-        request.accepted_impacts = self.accepted_impacts.clone();
-        if self
-            .decisions
-            .values()
-            .any(|d| *d == SemanticDecision::Candidate)
-        {
-            let final_value = self.combined_value(project, false)?;
-            let candidate = if project.elements.contains_key(&target) {
-                SemanticRecord::Element(
-                    serde_json::from_value(final_value)
-                        .map_err(|e| format!("Final target value: {e}"))?,
-                )
-            } else {
-                SemanticRecord::Relation(
-                    serde_json::from_value(final_value)
-                        .map_err(|e| format!("Final target value: {e}"))?,
-                )
-            };
-            request.candidates.push(candidate);
-        }
-        Ok(request)
-    }
-
-    /// Compose selected values for both the candidate and dependent form
-    /// controls. Incomplete inputs retain their stored shape only for controls;
-    /// request construction always requires every selected input to parse.
-    fn combined_value(&self, project: &Project, form_context: bool) -> Result<Value, String> {
-        let trace = self.effective_trace(project).ok_or("Choose a trace.")?;
-        let (source, target) = if self.direction == TransitionDirection::OaToSa {
-            (trace.oa, trace.sa)
-        } else {
-            (trace.sa, trace.oa)
-        };
-        let mut final_value = Draft::from_project(project, target)
-            .ok_or("Target has no editable record.")?
-            .value;
-        let mut map = BTreeMap::new();
-        for (oa, sa) in &self.references {
-            let (from, to) = if self.direction == TransitionDirection::OaToSa {
-                (*oa, *sa)
-            } else {
-                (*sa, *oa)
-            };
-            if map.insert(from, to).is_some_and(|old| old != to) {
-                return Err("Reverse reference correspondence is ambiguous.".into());
-            }
-        }
-        map.insert(source, target);
-        let original = final_value.clone();
-        let mut group_candidates = vec![];
-        // Outer groups precede nested groups and leaves. The core rejects actual
-        // overlapping replacement scopes; this order also supports first-equal
-        // discriminator acknowledgment together with explicit descendant values.
-        let mut decisions: Vec<_> = self.decisions.iter().collect();
-        decisions.sort_by_key(|(facet, _)| match facet {
-            FacetSelector::Occurrence(OccurrenceFacet::Constructor) => 0,
-            facet if scalar::grouped(facet) => 1,
-            _ => 2,
-        });
-        for (facet, decision) in decisions {
-            if *decision == SemanticDecision::KeepTarget {
-                continue;
-            }
-            if keyed::supported(facet) {
-                self.keyed_value(project, &trace, &mut final_value, facet, *decision)?;
-                continue;
-            }
-            let roots = constructors::roots(project, target, facet)
-                .ok_or("Selected property is not applicable to the target.")?;
-            let supplied = match decision {
-                SemanticDecision::KeepTarget => continue,
-                SemanticDecision::Candidate => {
-                    let draft = self
-                        .candidate_draft(facet)
-                        .ok_or("Target draft is unavailable.")?;
-                    match draft.materialize_scopes(&roots) {
-                        Ok(value) => value,
-                        Err(_) if form_context => draft.value.clone(),
-                        Err(error) => return Err(error),
-                    }
-                }
-                SemanticDecision::TakeSource if scalar::grouped(facet) => {
-                    if self.can_acknowledge_constructor(project, facet) {
-                        original.clone()
-                    } else {
-                        constructors::take_value(project, &trace, self.direction, facet, &map)?
-                    }
-                }
-                SemanticDecision::TakeSource => {
-                    let fact = capture_facet(project, trace.oa, trace.sa, facet)?;
-                    let value = scalar::source_value(&fact, self.direction.source_layer(), &map)?;
-                    let mut supplied = original.clone();
-                    *supplied
-                        .pointer_mut(&roots[0])
-                        .ok_or("Source property is unavailable.")? = value;
-                    supplied
-                }
-            };
-            for path in roots {
-                let value = supplied
-                    .pointer(&path)
-                    .cloned()
-                    .ok_or("Candidate property is no longer available.")?;
-                if scalar::grouped(facet) && *decision == SemanticDecision::Candidate {
-                    group_candidates.push((path.clone(), value.clone()));
-                }
-                *final_value.pointer_mut(&path).ok_or("Final target property is unavailable; resolve the overlapping constructor decision.")? = value;
-            }
-        }
-        if !form_context {
-            for (path, authored) in group_candidates {
-                if !original
-                    .pointer(&path)
-                    .zip(final_value.pointer(&path))
-                    .is_some_and(|(original, final_value)| {
-                        constructors::authored_agrees(original, &authored, final_value)
-                    })
-                {
-                    return Err("The constructor candidate and descendant decision propose different final values. Keep the kind or make their final values agree; both drafts are retained.".into());
-                }
-            }
-        }
-        Ok(final_value)
-    }
-
-    pub fn refresh(&mut self, project: &Project) {
-        self.plan = None;
-        self.proposed = None;
-        self.error = None;
-        let context = self.combined_value(project, true).ok();
-        if let Some(draft) = &mut self.draft {
-            draft.set_context(context.clone());
-        }
-        for draft in self.group_drafts.values_mut() {
-            draft.set_context(context.clone());
-        }
-        let Some(trace) = self.effective_trace(project) else {
-            self.error = Some(
-                "Several traces are available. Choose the correspondence and review history above."
-                    .into(),
-            );
-            return;
-        };
-        match semantic_facets(project, &trace, &self.references) {
-            Ok(mut facts) => {
-                // Explicit addresses survive catalog normalization, pairing changes and resets.
-                for selector in self.staged.iter().chain(self.decisions.keys()) {
-                    if !facts.iter().any(|f| &f.selector == selector) {
-                        match capture_facet(project, trace.oa, trace.sa, selector) {
-                            Ok(current) => {
-                                let previous = trace
-                                    .baseline
-                                    .as_ref()
-                                    .and_then(|b| b.semantic.as_ref())
-                                    .and_then(|b| {
-                                        b.facets.iter().find(|f| f.selector() == *selector)
-                                    });
-                                facts.push(FacetDrift {
-                                    selector: selector.clone(),
-                                    drift: facet_drift(&current, previous),
-                                    current,
-                                });
-                            }
-                            Err(error) => {
-                                self.error = Some(error);
-                                return;
-                            }
-                        }
-                    }
-                }
-                facts.sort_by(|a, b| a.selector.cmp(&b.selector));
-                self.facts = facts;
-            }
-            Err(error) => {
-                self.error = Some(error);
-                return;
-            }
-        }
-        if self
-            .selected
-            .as_ref()
-            .is_none_or(|s| !self.facts.iter().any(|f| &f.selector == s))
-        {
-            self.selected = self
-                .facts
-                .iter()
-                .find(|f| f.drift != Drift::Unchanged)
-                .or(self.facts.first())
-                .map(|f| f.selector.clone());
-        }
-        let request = match self.request(project) {
-            Ok(request) => request,
-            Err(error) => {
-                self.error = Some(error);
-                return;
-            }
-        };
-        match plan_semantic_transition(project, request) {
-            Ok(plan) => {
-                if plan.conflicts.is_empty() {
-                    match prepare_semantic_transition(project, &plan) {
-                        Ok(prepared) => self.proposed = Some(prepared.project),
-                        Err(error) => self.error = Some(error.to_string()),
-                    }
-                }
-                self.plan = Some(plan);
-            }
-            Err(error) => self.error = Some(error.to_string()),
-        }
-    }
-
-    pub fn command(&mut self, project: &Project) -> Result<Command, String> {
-        if self.decisions.is_empty() && self.resets.is_empty() {
-            return Err(
-                "Choose at least one property to review or an exact history observation to reset."
-                    .into(),
-            );
-        }
-        if let Some(error) = &self.error {
-            return Err(error.clone());
-        }
-        let plan = self
-            .plan
-            .as_ref()
-            .ok_or("Refresh the review preview before applying.")?;
-        prepare_semantic_transition(project, plan).map_err(|e| e.to_string())?;
-        Ok(Command::Batch(plan.commands.clone()))
-    }
-
-    pub fn can_apply(&self) -> bool {
-        (!self.decisions.is_empty() || !self.resets.is_empty())
-            && self.error.is_none()
-            && self
-                .plan
-                .as_ref()
-                .is_some_and(|p| p.conflicts.is_empty() && p.prepared_fingerprint.is_some())
-    }
-
-    pub fn all_references(&self, project: &Project, layer: Layer) -> Vec<Choice> {
-        let historical: BTreeSet<_> = self
-            .facts
-            .iter()
-            .flat_map(|f| scalar::references(&f.current))
-            .chain(
-                self.trace
-                    .and_then(|id| project.traces.get(&id))
-                    .and_then(|t| t.baseline.as_ref())
-                    .and_then(|b| b.semantic.as_ref())
-                    .into_iter()
-                    .flat_map(|b| b.facets.iter().flat_map(scalar::references)),
-            )
-            .collect();
-        let mut ids: BTreeSet<_> = project
-            .elements
-            .keys()
-            .chain(project.relations.keys())
-            .chain(project.artifact_links.keys())
-            .filter(|id| project.layer_of(**id) == Some(layer))
-            .copied()
-            .collect();
-        ids.extend(historical.into_iter().filter(|id| !project.contains(*id)));
-        let search = self.reference_search.to_lowercase();
-        let mut choices: Vec<_> = ids
-            .into_iter()
-            .map(|id| view::choice(project, id))
-            .filter(|c| search.is_empty() || c.label.to_lowercase().contains(&search))
-            .collect();
-        choices.sort_by(|a, b| a.label.cmp(&b.label));
-        choices
-    }
-}
-
-pub fn form_event(message: Message) -> Message {
-    let event = match message {
-        Message::Field(path, value) => Event::Input(path, value),
-        Message::FieldText(path, action) => Event::Text(path, action),
-        Message::FieldShape(path, value) => Event::Shape(path, value),
-        Message::FieldVariant(path, value) => Event::Variant(path, value),
-        Message::FieldArray(path, index, direction) => Event::Array(path, index, direction),
-        Message::FieldAppend(path, value) => Event::Append(path, value),
-        Message::FieldValuePath(path, key) => Event::ValuePath(path, key),
-        _ => Event::Preview,
-    };
-    Message::Workflow(crate::workflow::Event::Semantic(event))
-}

crates/oa-desktop/src/semantic_review/constructors.rs

@@ -1,327 +0,0 @@
-//! Closed constructor payload bindings. The core owns decisions and review scope;
-//! this adapter supplies complete target records for its Candidate agreement check.
-use super::{scalar, *};
-
-pub(super) fn selectors() -> [FacetSelector; 5] {
-    [
-        FacetSelector::Data(DataFacet::Constructor),
-        FacetSelector::Port(PortFacet::Constructor),
-        FacetSelector::Occurrence(OccurrenceFacet::Constructor),
-        FacetSelector::Occurrence(OccurrenceFacet::MessageKind),
-        FacetSelector::Event(EventFacet::Constructor),
-    ]
-}
-
-pub(super) fn roots(project: &Project, target: Id, facet: &FacetSelector) -> Option<Vec<String>> {
-    let root = scalar::binding(project, target, facet)?;
-    let mut roots = vec![root.clone()];
-    match facet {
-        FacetSelector::Data(DataFacet::Constructor) => {
-            roots.push(format!("{}/default", root.strip_suffix("/definition")?));
-        }
-        FacetSelector::Port(PortFacet::Constructor) => {
-            roots.push(format!("{}/legacy", root.strip_suffix("/contract")?));
-        }
-        _ => {}
-    }
-    Some(roots)
-}
-
-pub(super) fn available(project: &Project, trace: &Trace, facet: &FacetSelector) -> bool {
-    roots(project, trace.oa, facet).is_some() && roots(project, trace.sa, facet).is_some()
-}
-
-/// Used for explanation and explicit overlap controls, never for acknowledgment.
-pub(super) fn contains(group: &FacetSelector, facet: &FacetSelector) -> bool {
-    use FacetSelector as F;
-    match group {
-        F::Data(DataFacet::Constructor) => {
-            matches!(facet, F::Data(f) if *f != DataFacet::Unit) || matches!(facet, F::Literal(_))
-        }
-        F::Port(PortFacet::Constructor) => matches!(
-            facet,
-            F::Port(_)
-                | F::Member {
-                    collection: ReferenceCollection::FunctionInputItems
-                        | ReferenceCollection::FunctionOutputItems,
-                    ..
-                }
-        ),
-        F::Occurrence(OccurrenceFacet::Constructor) => {
-            matches!(facet, F::Occurrence(f) if !matches!(f, OccurrenceFacet::Precondition | OccurrenceFacet::Postcondition))
-                || matches!(
-                    facet,
-                    F::Annotation(_)
-                        | F::Binding(_)
-                        | F::Member {
-                            collection: ReferenceCollection::Steps
-                                | ReferenceCollection::FragmentBranches,
-                            ..
-                        }
-                        | F::Order(_)
-                )
-        }
-        F::Occurrence(OccurrenceFacet::MessageKind) => matches!(
-            facet,
-            F::Occurrence(OccurrenceFacet::MessageKind | OccurrenceFacet::TimerExpression)
-        ),
-        F::Event(EventFacet::Constructor) => matches!(
-            facet,
-            F::Event(_)
-                | F::Member {
-                    collection: ReferenceCollection::SignalItems,
-                    ..
-                }
-        ),
-        _ => false,
-    }
-}
-
-pub(super) fn description(facet: &FacetSelector) -> &'static str {
-    match facet {
-        FacetSelector::Data(_) => {
-            "Definition, bounds or literal members, record supertype and default. Unit stays independent."
-        }
-        FacetSelector::Port(_) => {
-            "Contract, item members and retained generic association. Owner stays independent."
-        }
-        FacetSelector::Occurrence(OccurrenceFacet::Constructor) => {
-            "Occurrence body, including references, message annotations, bindings and branch or step order. Pre/postconditions stay independent."
-        }
-        FacetSelector::Occurrence(_) => {
-            "Message kind and Timer Expression. Exchange references and annotations stay independent."
-        }
-        FacetSelector::Event(_) => {
-            "Event body, including signal items or its complete time/change expression."
-        }
-        _ => "",
-    }
-}
-
-fn chosen<T>(keys: &KeyPair<T>, layer: Layer) -> Option<&T> {
-    match layer {
-        Layer::Oa => keys.oa.as_ref(),
-        Layer::Sa => keys.sa.as_ref(),
-    }
-}
-
-// The source payload is mapped by the core's typed visitor, never by replacing
-// UUID-looking strings. For a historical same-kind Take, retain only current
-// target-present/source-absent rows with no prior source-present observation. The final core planner
-// checks this assembled record against its own independent expected result.
-pub(super) fn take_value(
-    project: &Project,
-    trace: &Trace,
-    direction: TransitionDirection,
-    facet: &FacetSelector,
-    map: &BTreeMap<Id, Id>,
-) -> Result<Value, String> {
-    let (source, target) = if direction == TransitionDirection::OaToSa {
-        (trace.oa, trace.sa)
-    } else {
-        (trace.sa, trace.oa)
-    };
-    let mut element = project
-        .elements
-        .get(&source)
-        .cloned()
-        .ok_or("Missing constructor source.")?;
-    if !message_kind::handles(facet) {
-        element.parent = None;
-        let mut missing = BTreeSet::new();
-        oa_core::references::visit_element_refs(&mut element, |id| {
-            if let Some(mapped) = map.get(id) {
-                *id = *mapped;
-            } else {
-                missing.insert(*id);
-            }
-        });
-        if !missing.is_empty() {
-            return Err(format!(
-                "Missing explicit reference correspondence: {missing:?}"
-            ));
-        }
-    }
-    let supplied = serde_json::to_value(element).map_err(|e| e.to_string())?;
-    let mut value = Draft::from_project(project, target)
-        .ok_or("Missing target draft.")?
-        .value;
-    for (from, to) in roots(project, source, facet)
-        .ok_or("Source group is unavailable.")?
-        .iter()
-        .zip(roots(project, target, facet).ok_or("Target group is unavailable.")?)
-    {
-        *value
-            .pointer_mut(&to)
-            .ok_or("Target group payload is unavailable.")? = supplied
-            .pointer(from)
-            .cloned()
-            .ok_or("Source group payload is unavailable.")?;
-    }
-    let current = capture_facet(project, trace.oa, trace.sa, facet)?;
-    if scalar::observation(&current, Layer::Oa) != scalar::observation(&current, Layer::Sa) {
-        return Ok(value);
-    }
-    let references = if direction == TransitionDirection::OaToSa {
-        map.clone()
-    } else {
-        map.iter().map(|(sa, oa)| (*oa, *sa)).collect()
-    };
-    let old = trace.baseline.as_ref().and_then(|b| b.semantic.as_ref());
-    for fact in semantic_facets(project, trace, &references)? {
-        if !contains(facet, &fact.selector) {
-            continue;
-        }
-        let Some((path, key)) =
-            target_row(project, target, &fact.selector, direction.target_layer())
-        else {
-            continue;
-        };
-        if row_present(&fact.current, direction.source_layer())
-            || !row_present(&fact.current, direction.target_layer())
-        {
-            continue;
-        }
-        let was_paired = old.is_some_and(|b| {
-            b.facets.iter().any(|previous| {
-                row_present(previous, direction.source_layer())
-                    && target_row(
-                        project,
-                        target,
-                        &previous.selector(),
-                        direction.target_layer(),
-                    )
-                    .as_ref()
-                        == Some(&(path.clone(), key.clone()))
-            })
-        });
-        if was_paired {
-            continue;
-        }
-        let row = scalar::value(&fact.current, direction.target_layer())
-            .ok_or("Target row is inapplicable.")?;
-        let items = value
-            .pointer_mut(&path)
-            .and_then(Value::as_array_mut)
-            .ok_or("Target collection is unavailable.")?;
-        match &fact.selector {
-            FacetSelector::Member { .. } | FacetSelector::Literal(_) => {
-                if row == Value::Bool(true) && !items.contains(&key) {
-                    items.push(key);
-                } else if row == Value::Bool(false) {
-                    items.retain(|v| v != &key);
-                }
-            }
-            FacetSelector::Annotation(_) => {
-                items.retain(|v| {
-                    serde_json::from_value::<MessageValue>(v.clone())
-                        .ok()
-                        .map(|v| serde_json::to_value(AnnotationKey::from(&v)).unwrap())
-                        .as_ref()
-                        != Some(&key)
-                });
-                if !row.is_null() {
-                    items.push(row);
-                }
-            }
-            FacetSelector::Binding(_) => {
-                items.retain(|v| v.get("referenced") != Some(&key));
-                if !row.is_null() {
-                    items.push(row);
-                }
-            }
-            _ => unreachable!(),
-        }
-    }
-    Ok(value)
-}
-
-fn row_present(fact: &FacetReview, layer: Layer) -> bool {
-    match fact {
-        FacetReview::Member { .. } | FacetReview::Literal { .. } => {
-            scalar::value(fact, layer) == Some(Value::Bool(true))
-        }
-        FacetReview::Annotation { .. } | FacetReview::Binding { .. } => {
-            scalar::value(fact, layer).is_some_and(|value| !value.is_null())
-        }
-        _ => false,
-    }
-}
-
-fn row_key(facet: &FacetSelector, layer: Layer) -> Option<Value> {
-    match facet {
-        FacetSelector::Member { keys, .. } | FacetSelector::Binding(keys) => {
-            chosen(keys, layer).map(|v| serde_json::json!(v))
-        }
-        FacetSelector::Literal(keys) => chosen(keys, layer).map(|v| serde_json::json!(v)),
-        FacetSelector::Annotation(keys) => chosen(keys, layer).map(|v| serde_json::json!(v)),
-        _ => None,
-    }
-}
-fn target_row(
-    project: &Project,
-    target: Id,
-    facet: &FacetSelector,
-    layer: Layer,
-) -> Option<(String, Value)> {
-    let key = row_key(facet, layer)?;
-    let (group, suffix) = match facet {
-        FacetSelector::Literal(_) => (
-            FacetSelector::Data(DataFacet::Constructor),
-            "/Enumeration/literals",
-        ),
-        FacetSelector::Binding(_) => (
-            FacetSelector::Occurrence(OccurrenceFacet::Constructor),
-            "/ScenarioUse/bindings",
-        ),
-        FacetSelector::Annotation(_) => (
-            FacetSelector::Occurrence(OccurrenceFacet::Constructor),
-            "/Exchange/values",
-        ),
-        FacetSelector::Member { collection, .. } => match collection {
-            ReferenceCollection::FunctionInputItems => (
-                FacetSelector::Port(PortFacet::Constructor),
-                "/FunctionInput/incoming_items",
-            ),
-            ReferenceCollection::FunctionOutputItems => (
-                FacetSelector::Port(PortFacet::Constructor),
-                "/FunctionOutput/outgoing_items",
-            ),
-            ReferenceCollection::SignalItems => (
-                FacetSelector::Event(EventFacet::Constructor),
-                "/Signal/items",
-            ),
-            ReferenceCollection::Steps => (
-                FacetSelector::Occurrence(OccurrenceFacet::Constructor),
-                "/Branch/occurrences",
-            ),
-            ReferenceCollection::FragmentBranches => (
-                FacetSelector::Occurrence(OccurrenceFacet::Constructor),
-                "/Fragment/branches",
-            ),
-            _ => return None,
-        },
-        _ => return None,
-    };
-    Some((
-        format!("{}{suffix}", scalar::binding(project, target, &group)?),
-        key,
-    ))
-}
-
-/// A selected descendant may fill untouched group fields during first-equal
-/// acknowledgment, but cannot silently replace an authored group field.
-pub(super) fn authored_agrees(original: &Value, authored: &Value, final_value: &Value) -> bool {
-    if original == authored || authored == final_value {
-        return true;
-    }
-    match (original, authored, final_value) {
-        (Value::Object(a), Value::Object(b), Value::Object(c)) if a.keys().eq(b.keys()) => {
-            b.iter().all(|(key, v)| {
-                c.get(key)
-                    .is_some_and(|final_value| authored_agrees(&a[key], v, final_value))
-            })
-        }
-        _ => false,
-    }
-}

crates/oa-desktop/src/semantic_review/history.rs

@@ -1,43 +0,0 @@
-use super::*;
-
-pub(super) fn resettable(facet: &FacetSelector) -> bool {
-    !matches!(facet, FacetSelector::Artifact { .. })
-}
-
-impl State {
-    pub(super) fn effective_trace(&self, project: &Project) -> Option<Trace> {
-        let mut trace = project.traces.get(&self.trace?)?.clone();
-        if let Some(baseline) = trace.baseline.as_mut().and_then(|b| b.semantic.as_mut()) {
-            baseline
-                .facets
-                .retain(|f| !self.resets.contains(&f.selector()));
-        }
-        Some(trace)
-    }
-
-    pub(super) fn reset_history(
-        &mut self,
-        project: &Project,
-        facet: FacetSelector,
-        reset: bool,
-    ) -> Result<(), String> {
-        if !reset && self.resets.remove(&facet) {
-            return Ok(());
-        }
-        let exists = self
-            .trace
-            .and_then(|id| project.traces.get(&id))
-            .and_then(|t| t.baseline.as_ref())
-            .and_then(|b| b.semantic.as_ref())
-            .is_some_and(|b| b.facets.iter().any(|f| f.selector() == facet));
-        if !exists || !resettable(&facet) {
-            return Err("Choose an exact existing non-artifact observation to reset.".into());
-        }
-        if reset {
-            self.resets.insert(facet);
-        } else {
-            self.resets.remove(&facet);
-        }
-        Ok(())
-    }
-}

crates/oa-desktop/src/semantic_review/keyed.rs

@@ -1,263 +0,0 @@
-//! Closed presence-only adapter. The core independently validates the full final record.
-use super::*;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Family {
-    Member(ReferenceCollection),
-    Literal,
-}
-impl std::fmt::Display for Family {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(match self {
-            Self::Member(ReferenceCollection::FunctionInputItems) => "Function input items",
-            Self::Member(ReferenceCollection::FunctionOutputItems) => "Function output items",
-            Self::Member(ReferenceCollection::SignalItems) => "Signal items",
-            Self::Member(ReferenceCollection::ExchangeItems) => "Exchange items",
-            Self::Member(ReferenceCollection::TransitionTriggers) => "Transition triggers",
-            Self::Member(ReferenceCollection::TransitionEffects) => "Transition effects",
-            Self::Member(ReferenceCollection::Constrained) => "Constrained identities",
-            Self::Literal => "Enumeration literals",
-            _ => "Ordered membership (read-only)",
-        })
-    }
-}
-pub(super) const FAMILIES: [Family; 8] = [
-    Family::Member(ReferenceCollection::FunctionInputItems),
-    Family::Member(ReferenceCollection::FunctionOutputItems),
-    Family::Member(ReferenceCollection::SignalItems),
-    Family::Member(ReferenceCollection::ExchangeItems),
-    Family::Member(ReferenceCollection::TransitionTriggers),
-    Family::Member(ReferenceCollection::TransitionEffects),
-    Family::Member(ReferenceCollection::Constrained),
-    Family::Literal,
-];
-pub(super) fn family(facet: &FacetSelector) -> Option<Family> {
-    let family = match facet {
-        FacetSelector::Member { collection, .. } => Family::Member(*collection),
-        FacetSelector::Literal(_) => Family::Literal,
-        _ => return None,
-    };
-    FAMILIES.contains(&family).then_some(family)
-}
-pub(super) fn supported(facet: &FacetSelector) -> bool {
-    family(facet).is_some()
-}
-
-// Fixed paths for the seven unordered collections and the exact enum literal set.
-// They are selected by the typed facet; callers cannot supply arbitrary paths.
-pub(super) fn path(value: &Value, family: Family) -> Option<String> {
-    let prefixes = ["/body/Oa/Shared", "/body/Sa/Shared"];
-    let tails: &[&str] = match family {
-        Family::Member(ReferenceCollection::FunctionInputItems) => {
-            &["Port/contract/FunctionInput/incoming_items"]
-        }
-        Family::Member(ReferenceCollection::FunctionOutputItems) => {
-            &["Port/contract/FunctionOutput/outgoing_items"]
-        }
-        Family::Member(ReferenceCollection::SignalItems) => &["Event/body/Signal/items"],
-        Family::Member(ReferenceCollection::Constrained) => &["Constraint/constrained"],
-        Family::Literal => &["DataType/definition/Enumeration/literals"],
-        Family::Member(ReferenceCollection::ExchangeItems) => {
-            return ["Interaction", "FunctionalExchange", "BoundaryExchange"]
-                .iter()
-                .map(|kind| format!("/body/{kind}/items"))
-                .find(|p| value.pointer(p).is_some_and(Value::is_array));
-        }
-        Family::Member(ReferenceCollection::TransitionTriggers) => {
-            return value
-                .pointer("/body/StateTransition/triggers")
-                .is_some_and(Value::is_array)
-                .then(|| "/body/StateTransition/triggers".into());
-        }
-        Family::Member(ReferenceCollection::TransitionEffects) => {
-            return value
-                .pointer("/body/StateTransition/effects")
-                .is_some_and(Value::is_array)
-                .then(|| "/body/StateTransition/effects".into());
-        }
-        _ => return None,
-    };
-    prefixes
-        .iter()
-        .flat_map(|prefix| tails.iter().map(move |tail| format!("{prefix}/{tail}")))
-        .find(|p| value.pointer(p).is_some_and(Value::is_array))
-}
-fn key(facet: &FacetSelector, layer: Layer) -> Option<Value> {
-    match facet {
-        FacetSelector::Member { keys, .. } => if layer == Layer::Oa { keys.oa } else { keys.sa }
-            .map(|id| serde_json::to_value(id).expect("Id")),
-        FacetSelector::Literal(keys) => if layer == Layer::Oa {
-            keys.oa.as_ref()
-        } else {
-            keys.sa.as_ref()
-        }
-        .map(|v| Value::String(v.clone())),
-        _ => None,
-    }
-}
-pub(super) fn overlap(a: &FacetSelector, b: &FacetSelector) -> bool {
-    if family(a).is_none() || family(a) != family(b) {
-        return false;
-    }
-    [Layer::Oa, Layer::Sa]
-        .into_iter()
-        .any(|layer| key(a, layer).is_some() && key(a, layer) == key(b, layer))
-}
-pub(super) fn project_presence(
-    value: &mut Value,
-    facet: &FacetSelector,
-    layer: Layer,
-    present: bool,
-) -> Result<(), String> {
-    let family = family(facet).ok_or("This keyed family remains read-only.")?;
-    let key = key(facet, layer)
-        .ok_or("Choose the destination identity in Members before setting or taking presence.")?;
-    let path =
-        path(value, family).ok_or("This collection is not applicable to the destination kind.")?;
-    let list = value
-        .pointer_mut(&path)
-        .and_then(Value::as_array_mut)
-        .ok_or("Destination collection is unavailable.")?;
-    if present {
-        if !list.contains(&key) {
-            list.push(key);
-        }
-    } else {
-        list.retain(|v| v != &key);
-    }
-    Ok(())
-}
-
-impl State {
-    pub(super) fn keyed_value(
-        &self,
-        project: &Project,
-        trace: &Trace,
-        value: &mut Value,
-        facet: &FacetSelector,
-        decision: SemanticDecision,
-    ) -> Result<(), String> {
-        let present = match decision {
-            SemanticDecision::KeepTarget => return Ok(()),
-            SemanticDecision::TakeSource => {
-                // A missing source identity is a target-local row, not a removal.
-                if key(facet, self.direction.source_layer()).is_none() {
-                    return Ok(());
-                }
-                let fact = capture_facet(project, trace.oa, trace.sa, facet)?;
-                scalar::value(&fact, self.direction.source_layer()).and_then(|v| v.as_bool()).ok_or("Source collection is not applicable; choose an explicit final presence or Keep.")?
-            }
-            SemanticDecision::Candidate => *self
-                .presence
-                .get(facet)
-                .ok_or("Choose final membership presence.")?,
-        };
-        project_presence(value, facet, self.direction.target_layer(), present)
-    }
-
-    pub(super) fn member_families(&self, project: &Project) -> Vec<Family> {
-        let Some(trace) = self.effective_trace(project) else {
-            return vec![];
-        };
-        let values: Vec<_> = [trace.oa, trace.sa]
-            .into_iter()
-            .filter_map(|id| Draft::from_project(project, id).map(|d| d.value))
-            .collect();
-        FAMILIES
-            .into_iter()
-            .filter(|family| values.iter().any(|value| path(value, *family).is_some()))
-            .collect()
-    }
-
-    pub(super) fn member_choices(&self, project: &Project, layer: Layer) -> Vec<Choice> {
-        let Some(trace) = self.effective_trace(project) else {
-            return vec![];
-        };
-        let id = if layer == Layer::Oa {
-            trace.oa
-        } else {
-            trace.sa
-        };
-        let Some(mut draft) = Draft::from_project(project, id) else {
-            return vec![];
-        };
-        if layer == self.direction.target_layer() {
-            draft.set_context(self.combined_value(project, true).ok());
-        }
-        let selected = if layer == Layer::Oa {
-            &self.member_oa
-        } else {
-            &self.member_sa
-        };
-        let Some(path) = path(&draft.context_value(), self.member_family) else {
-            return selected.iter().cloned().collect();
-        };
-        crate::forms::reference_choices(
-            &draft,
-            project,
-            &format!("{path}/0"),
-            selected.as_ref().map_or(Id::nil(), |c| c.id),
-        )
-        .into_iter()
-        .filter(|c| !c.id.is_nil())
-        .collect()
-    }
-
-    pub(super) fn edit_pair(
-        &mut self,
-        project: &Project,
-        facet: FacetSelector,
-    ) -> Result<(), String> {
-        self.member_family = family(&facet).ok_or("This keyed family remains read-only.")?;
-        match facet {
-            FacetSelector::Member { keys, .. } => {
-                self.member_oa = keys.oa.map(|id| view::choice(project, id));
-                self.member_sa = keys.sa.map(|id| view::choice(project, id));
-            }
-            FacetSelector::Literal(keys) => {
-                self.literal_oa = keys.oa.is_some();
-                self.literal_sa = keys.sa.is_some();
-                self.literal = keys.oa.or(keys.sa).unwrap_or_default();
-            }
-            _ => unreachable!(),
-        }
-        self.tab = Tab::Members;
-        Ok(())
-    }
-
-    pub(super) fn stage_member(&mut self, project: &Project) -> Result<(), String> {
-        if !FAMILIES.contains(&self.member_family) {
-            return Err("This keyed family remains read-only.".into());
-        }
-        let facet = match self.member_family {
-            Family::Member(collection) => FacetSelector::Member {
-                collection,
-                keys: KeyPair {
-                    oa: self.member_oa.as_ref().map(|c| c.id),
-                    sa: self.member_sa.as_ref().map(|c| c.id),
-                },
-            },
-            Family::Literal => FacetSelector::Literal(KeyPair {
-                oa: self.literal_oa.then(|| self.literal.clone()),
-                sa: self.literal_sa.then(|| self.literal.clone()),
-            }),
-        };
-        let trace = self.effective_trace(project).ok_or("Choose a trace.")?;
-        capture_facet(project, trace.oa, trace.sa, &facet)?;
-        if let FacetSelector::Member {
-            keys:
-                KeyPair {
-                    oa: Some(oa),
-                    sa: Some(sa),
-                },
-            ..
-        } = &facet
-        {
-            self.references.insert(*oa, *sa);
-        }
-        self.staged.insert(facet.clone());
-        self.selected = Some(facet);
-        self.tab = Tab::Facts;
-        Ok(())
-    }
-}

crates/oa-desktop/src/semantic_review/keyed_tests.rs

@@ -1,782 +0,0 @@
-use super::{tests::*, *};
-use crate::{app::App, document::Document};
-
-fn errors(s: &State) -> String {
-    s.error
-        .iter()
-        .chain(s.plan.iter().flat_map(|p| &p.conflicts))
-        .cloned()
-        .collect::<Vec<_>>()
-        .join("; ")
-}
-fn put(p: &mut Project, owner: Id, facet: &FacetSelector, present: bool) {
-    let layer = p.layer_of(owner).unwrap();
-    let mut value = Draft::from_project(p, owner).unwrap().value;
-    keyed::project_presence(&mut value, facet, layer, present).unwrap();
-    if let Some(element) = p.elements.get_mut(&owner) {
-        *element = serde_json::from_value(value).unwrap();
-    } else {
-        p.relations
-            .insert(owner, serde_json::from_value(value).unwrap());
-    }
-}
-fn contains(p: &Project, owner: Id, facet: &FacetSelector, oa: Id, sa: Id) -> bool {
-    scalar::value(
-        &capture_facet(p, oa, sa, facet).unwrap(),
-        p.layer_of(owner).unwrap(),
-    )
-    .unwrap()
-    .as_bool()
-    .unwrap()
-}
-fn history(p: &mut Project, trace: Id, selectors: &[FacetSelector]) {
-    let t = &p.traces[&trace];
-    let baseline = TraceBaseline {
-        oa: p.properties(t.oa).unwrap(),
-        sa: p.properties(t.sa).unwrap(),
-        semantic: Some(SemanticBaseline {
-            facets: selectors
-                .iter()
-                .map(|s| capture_facet(p, t.oa, t.sa, s).unwrap())
-                .collect(),
-        }),
-    };
-    p.traces.get_mut(&trace).unwrap().baseline = Some(baseline);
-}
-fn literal(name: &str) -> FacetSelector {
-    FacetSelector::Literal(KeyPair {
-        oa: Some(name.into()),
-        sa: Some(name.into()),
-    })
-}
-fn enum_pair() -> (Project, Id, Id, Id) {
-    let mut p = Project::empty();
-    let mut ids = vec![];
-    for layer in [Layer::Oa, Layer::Sa] {
-        let id = p.add_element(Kind::DataType, layer, "Enum", None).unwrap();
-        *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::DataType {
-            definition: DataTypeDefinition::Enumeration {
-                literals: vec!["retained".into()],
-            },
-            default: Some(DataValue::Enumeration("retained".into())),
-            unit: String::new(),
-        };
-        ids.push(id);
-    }
-    let trace = add_trace(&mut p, ids[0], ids[1], "Literal review");
-    (p, ids[0], ids[1], trace)
-}
-fn member_pair(collection: ReferenceCollection) -> (Project, Id, Id, Id, FacetSelector, [Id; 2]) {
-    let mut p = Project::empty();
-    let mut owners = vec![];
-    let mut keys = vec![];
-    let mut locals = vec![];
-    for layer in [Layer::Oa, Layer::Sa] {
-        let work = if layer == Layer::Oa {
-            Kind::Activity
-        } else {
-            Kind::Function
-        };
-        let kind = match collection {
-            ReferenceCollection::TransitionTriggers => Kind::Event,
-            ReferenceCollection::TransitionEffects | ReferenceCollection::Constrained => work,
-            _ => Kind::ExchangeItem,
-        };
-        let key = p.add_element(kind, layer, "Mapped member", None).unwrap();
-        let local = p.add_element(kind, layer, "Local member", None).unwrap();
-        let owner = match collection {
-            ReferenceCollection::SignalItems => {
-                let id = p.add_element(Kind::Event, layer, "Signal", None).unwrap();
-                *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::Event {
-                    body: EventBody::Signal { items: vec![] },
-                };
-                id
-            }
-            ReferenceCollection::Constrained => p
-                .add_element(Kind::Constraint, layer, "Constraint", None)
-                .unwrap(),
-            ReferenceCollection::ExchangeItems => {
-                let a = p.add_element(work, layer, "From", None).unwrap();
-                let b = p.add_element(work, layer, "To", None).unwrap();
-                let id = p.relate(
-                    if layer == Layer::Oa {
-                        RelationKind::Interaction
-                    } else {
-                        RelationKind::FunctionalExchange
-                    },
-                    "Exchange",
-                    a,
-                    b,
-                );
-                if let RelationBody::FunctionalExchange {
-                    source_port,
-                    target_port,
-                    ..
-                } = p.relations[&id].body
-                {
-                    for port in [source_port, target_port] {
-                        if let Some(SharedBody::Port { contract, .. }) =
-                            p.elements.get_mut(&port).unwrap().shared_mut()
-                        {
-                            match contract {
-                                PortContract::FunctionInput { incoming_items } => {
-                                    *incoming_items = vec![key, local]
-                                }
-                                PortContract::FunctionOutput { outgoing_items } => {
-                                    *outgoing_items = vec![key, local]
-                                }
-                                _ => unreachable!(),
-                            }
-                        }
-                    }
-                }
-                id
-            }
-            ReferenceCollection::TransitionTriggers | ReferenceCollection::TransitionEffects => {
-                let machine = p
-                    .add_element(Kind::StateMachine, layer, "Machine", None)
-                    .unwrap();
-                let region = p
-                    .add_element(Kind::Region, layer, "Region", Some(machine))
-                    .unwrap();
-                let state = p
-                    .add_element(Kind::State, layer, "State", Some(region))
-                    .unwrap();
-                p.relate(RelationKind::StateTransition, "Transition", state, state)
-            }
-            ReferenceCollection::FunctionInputItems | ReferenceCollection::FunctionOutputItems => {
-                let parent = p.add_element(work, layer, "Owner", None).unwrap();
-                let id = Id::new_v4();
-                let contract = if layer == Layer::Oa {
-                    PortContract::Legacy
-                } else if collection == ReferenceCollection::FunctionInputItems {
-                    PortContract::FunctionInput {
-                        incoming_items: vec![],
-                    }
-                } else {
-                    PortContract::FunctionOutput {
-                        outgoing_items: vec![],
-                    }
-                };
-                let mut port = ports::make_port(&p, id, parent, "Port", contract).unwrap();
-                if layer == Layer::Oa
-                    && let Some(SharedBody::Port { legacy, .. }) = port.shared_mut()
-                {
-                    *legacy = Some(LegacyPortContract {
-                        direction: PortDirection::InOut,
-                        interface: None,
-                    });
-                }
-                p.elements.insert(id, port);
-                id
-            }
-            _ => unreachable!(),
-        };
-        owners.push(owner);
-        keys.push(key);
-        locals.push(local);
-    }
-    let trace = add_trace(&mut p, owners[0], owners[1], "Membership review");
-    let facet = FacetSelector::Member {
-        collection,
-        keys: KeyPair {
-            oa: Some(keys[0]),
-            sa: Some(keys[1]),
-        },
-    };
-    (
-        p,
-        owners[0],
-        owners[1],
-        trace,
-        facet,
-        [locals[0], locals[1]],
-    )
-}
-fn stage(app: &mut App, facet: &FacetSelector) {
-    send(app, Event::EditPair(facet.clone()));
-    send(app, Event::StageMember);
-    assert_eq!(
-        state(app).selected.as_ref(),
-        Some(facet),
-        "{}",
-        errors(state(app))
-    );
-}
-
-#[test]
-fn unordered_members_keep_take_candidate_preserve_other_rows_both_directions() {
-    for collection in [
-        ReferenceCollection::SignalItems,
-        ReferenceCollection::ExchangeItems,
-        ReferenceCollection::TransitionTriggers,
-        ReferenceCollection::TransitionEffects,
-        ReferenceCollection::Constrained,
-    ] {
-        for reverse in [false, true] {
-            for decision in [
-                SemanticDecision::KeepTarget,
-                SemanticDecision::TakeSource,
-                SemanticDecision::Candidate,
-            ] {
-                let (mut p, oa, sa, trace, facet, locals) = member_pair(collection);
-                let (source, target, local) = if reverse {
-                    (sa, oa, locals[0])
-                } else {
-                    (oa, sa, locals[1])
-                };
-                put(&mut p, source, &facet, true);
-                let local_facet = FacetSelector::Member {
-                    collection,
-                    keys: KeyPair {
-                        oa: reverse.then_some(local),
-                        sa: (!reverse).then_some(local),
-                    },
-                };
-                put(&mut p, target, &local_facet, true);
-                let mut app = App::with_project(p);
-                let before = app.document.snapshot();
-                start(&mut app, source);
-                stage(&mut app, &facet);
-                decide(&mut app, facet.clone(), decision);
-                if decision == SemanticDecision::Candidate {
-                    send(&mut app, Event::Presence(facet.clone(), true));
-                }
-                // A target-only Take is an explicit acknowledgment, never implicit removal.
-                decide(&mut app, local_facet.clone(), SemanticDecision::TakeSource);
-                assert!(
-                    state(&app).can_apply(),
-                    "{collection:?} reverse={reverse} {decision:?}: {}",
-                    errors(state(&app))
-                );
-                let proposed = state(&app).proposed.clone().unwrap();
-                assert_eq!(app.document.bundle(), &before.bundle);
-                apply(&mut app);
-                assert!(app.workflow.is_none(), "{}", app.status);
-                assert_eq!(app.project(), &proposed);
-                assert_eq!(
-                    contains(app.project(), target, &facet, oa, sa),
-                    decision != SemanticDecision::KeepTarget
-                );
-                assert!(contains(app.project(), target, &local_facet, oa, sa));
-                assert!(app.project().elements.contains_key(&local));
-                assert_eq!(
-                    app.project().traces[&trace]
-                        .baseline
-                        .as_ref()
-                        .unwrap()
-                        .semantic
-                        .as_ref()
-                        .unwrap()
-                        .facets
-                        .len(),
-                    2
-                );
-                let _ = app.update(Message::Undo);
-                assert_eq!(app.document.bundle(), &before.bundle);
-            }
-        }
-    }
-}
-
-#[test]
-fn function_port_members_use_existing_typed_choices_and_preserve_oa_legacy() {
-    for collection in [
-        ReferenceCollection::FunctionInputItems,
-        ReferenceCollection::FunctionOutputItems,
-    ] {
-        let (p, oa, sa, _, facet, _) = member_pair(collection);
-        let FacetSelector::Member { keys, .. } = &facet else {
-            unreachable!()
-        };
-        let mut app = App::with_project(p);
-        start(&mut app, oa);
-        assert_eq!(
-            state(&app).member_families(app.project()),
-            vec![keyed::Family::Member(collection)]
-        );
-        send(&mut app, Event::EditPair(facet.clone()));
-        assert!(
-            state(&app)
-                .member_choices(app.project(), Layer::Sa)
-                .iter()
-                .any(|c| Some(c.id) == keys.sa)
-        );
-        send(&mut app, Event::StageMember);
-        decide(&mut app, facet.clone(), SemanticDecision::Candidate);
-        send(&mut app, Event::Presence(facet.clone(), true));
-        assert!(state(&app).can_apply(), "{}", errors(state(&app)));
-        apply(&mut app);
-        assert!(contains(app.project(), sa, &facet, oa, sa));
-        assert!(matches!(
-            app.project().elements[&oa].shared(),
-            Some(SharedBody::Port {
-                contract: PortContract::Legacy,
-                ..
-            })
-        ));
-        start(&mut app, sa);
-        stage(&mut app, &facet);
-        decide(&mut app, facet.clone(), SemanticDecision::KeepTarget);
-        assert!(state(&app).can_apply(), "{}", errors(state(&app)));
-        decide(&mut app, facet.clone(), SemanticDecision::Candidate);
-        send(&mut app, Event::Presence(facet, true));
-        assert!(
-            !state(&app).can_apply(),
-            "OA typed membership must remain inapplicable"
-        );
-    }
-}
-
-#[test]
-fn exact_literal_new_rows_and_removals_commit_both_directions_without_default_loss() {
-    for reverse in [false, true] {
-        let (mut p, oa, sa, _) = enum_pair();
-        let (source, target) = if reverse { (sa, oa) } else { (oa, sa) };
-        let incoming = literal(" New value ");
-        put(&mut p, source, &incoming, true);
-        let removed = literal("old");
-        put(&mut p, target, &removed, true);
-        let created = literal("new value");
-        let mut app = App::with_project(p);
-        start(&mut app, source);
-        for (facet, decision) in [
-            (&incoming, SemanticDecision::TakeSource),
-            (&removed, SemanticDecision::Candidate),
-            (&created, SemanticDecision::Candidate),
-        ] {
-            stage(&mut app, facet);
-            decide(&mut app, facet.clone(), decision);
-            if decision == SemanticDecision::Candidate {
-                send(&mut app, Event::Presence(facet.clone(), facet == &created));
-            }
-        }
-        assert!(state(&app).can_apply(), "{}", errors(state(&app)));
-        apply(&mut app);
-        assert!(contains(app.project(), target, &incoming, oa, sa));
-        assert!(contains(app.project(), target, &created, oa, sa));
-        assert!(!contains(app.project(), target, &removed, oa, sa));
-        assert!(
-            matches!(app.project().elements[&target].shared(),Some(SharedBody::DataType { default: Some(DataValue::Enumeration(value)), .. }) if value=="retained")
-        );
-        let reopened = Document::from_bundle(
-            app.document.bundle().clone(),
-            source_project::ProjectLimits::default(),
-        )
-        .unwrap();
-        assert_eq!(reopened.project(), app.project());
-    }
-}
-
-#[test]
-fn exact_reset_only_is_one_history_source_transaction_and_undo_redo_both_directions() {
-    for reverse in [false, true] {
-        let (mut p, oa, sa, trace) = enum_pair();
-        let reset = literal("retained");
-        let kept = FacetSelector::Header(HeaderFacet::Name);
-        history(&mut p, trace, &[reset.clone(), kept.clone()]);
-        let previous = p.traces[&trace].baseline.clone().unwrap();
-        let mut app = App::with_project(p);
-        let mut bundle = app.document.bundle().clone();
-        bundle
-            .files
-            .get_mut(&bundle.entry)
-            .unwrap()
-            .insert_str(0, "// Exact review rationale survives reset.\n");
-        app.document.apply_bundle(bundle).unwrap();
-        let before = app.document.snapshot();
-        let revision = app.document.revision();
-        start(&mut app, if reverse { sa } else { oa });
-        send(&mut app, Event::Reset(reset.clone(), true));
-        assert!(state(&app).decisions.is_empty());
-        assert!(state(&app).can_apply(), "{}", errors(state(&app)));
-        assert_eq!(
-            state(&app)
-                .facts
-                .iter()
-                .find(|f| f.selector == reset)
-                .unwrap()
-                .drift,
-            Drift::Unreviewed
-        );
-        send(&mut app, Event::Reset(reset.clone(), false));
-        assert!(!state(&app).can_apply());
-        assert_eq!(
-            state(&app)
-                .facts
-                .iter()
-                .find(|f| f.selector == reset)
-                .unwrap()
-                .drift,
-            Drift::Unchanged
-        );
-        send(&mut app, Event::Reset(reset, true));
-        apply(&mut app);
-        assert_eq!(app.document.revision(), revision + 1);
-        assert_eq!(app.project().elements, before.decoded.project.elements);
-        let after = &app.project().traces[&trace].baseline.as_ref().unwrap();
-        assert_eq!(after.oa, previous.oa);
-        assert_eq!(after.sa, previous.sa);
-        assert_eq!(
-            after
-                .semantic
-                .as_ref()
-                .unwrap()
-                .facets
-                .iter()
-                .map(FacetReview::selector)
-                .collect::<Vec<_>>(),
-            vec![kept]
-        );
-        assert!(
-            app.document.bundle().files[&app.document.bundle().entry]
-                .contains("// Exact review rationale survives reset.")
-        );
-        let accepted = app.document.snapshot();
-        let _ = app.update(Message::Undo);
-        assert_eq!(app.document.bundle(), &before.bundle);
-        let _ = app.update(Message::Redo);
-        assert_eq!(app.document.bundle(), &accepted.bundle);
-    }
-}
-
-#[test]
-fn historical_one_sided_pair_migration_requires_exact_reset_and_explicit_overlap_resolution() {
-    for reverse in [false, true] {
-        let (mut p, oa, sa, trace, paired, _) = member_pair(ReferenceCollection::SignalItems);
-        let FacetSelector::Member { collection, keys } = &paired else {
-            unreachable!()
-        };
-        let (source, target) = if reverse { (sa, oa) } else { (oa, sa) };
-        let previous = FacetSelector::Member {
-            collection: *collection,
-            keys: KeyPair {
-                oa: if reverse { None } else { keys.oa },
-                sa: if reverse { keys.sa } else { None },
-            },
-        };
-        put(&mut p, source, &paired, true);
-        history(&mut p, trace, std::slice::from_ref(&previous));
-        let mut app = App::with_project(p);
-        start(&mut app, source);
-        decide(&mut app, previous.clone(), SemanticDecision::KeepTarget);
-        stage(&mut app, &paired);
-        decide(&mut app, paired.clone(), SemanticDecision::Candidate);
-        send(&mut app, Event::Presence(paired.clone(), true));
-        assert!(!state(&app).can_apply());
-        assert_eq!(state(&app).decisions.len(), 2);
-        send(&mut app, Event::Decide(previous.clone(), None));
-        assert!(
-            !state(&app).can_apply(),
-            "Historic pair cannot silently migrate"
-        );
-        send(&mut app, Event::Reset(previous.clone(), true));
-        assert!(state(&app).can_apply(), "{}", errors(state(&app)));
-        send(&mut app, Event::Reset(previous, false));
-        assert!(!state(&app).can_apply());
-        assert!(state(&app).presence[&paired]);
-        let old = state(&app).resets.clone();
-        assert!(old.is_empty());
-        let historic = app.project().traces[&trace]
-            .baseline
-            .as_ref()
-            .unwrap()
-            .semantic
-            .as_ref()
-            .unwrap()
-            .facets[0]
-            .selector();
-        send(&mut app, Event::Reset(historic, true));
-        apply(&mut app);
-        assert!(contains(app.project(), target, &paired, oa, sa));
-        assert_eq!(
-            app.project().traces[&trace]
-                .baseline
-                .as_ref()
-                .unwrap()
-                .semantic
-                .as_ref()
-                .unwrap()
-                .facets[0]
-                .selector(),
-            paired
-        );
-    }
-}
-
-#[test]
-fn reset_precedes_equal_constructor_candidate_and_preserves_independent_literal_draft() {
-    for reverse in [false, true] {
-        let (mut p, oa, sa, trace) = enum_pair();
-        let ctor = FacetSelector::Data(DataFacet::Constructor);
-        history(&mut p, trace, std::slice::from_ref(&ctor));
-        let mut app = App::with_project(p);
-        start(&mut app, if reverse { sa } else { oa });
-        let created = literal("separate");
-        stage(&mut app, &created);
-        decide(&mut app, created.clone(), SemanticDecision::Candidate);
-        send(&mut app, Event::Presence(created.clone(), true));
-        send(&mut app, Event::Reset(ctor.clone(), true));
-        decide(&mut app, ctor.clone(), SemanticDecision::Candidate);
-        assert!(state(&app).can_acknowledge_constructor(app.project(), &ctor));
-        assert!(state(&app).can_apply(), "{}", errors(state(&app)));
-        let reviewed = &state(&app).plan.as_ref().unwrap().reviews[0];
-        assert_eq!(
-            reviewed
-                .acknowledged
-                .iter()
-                .cloned()
-                .collect::<BTreeSet<_>>(),
-            BTreeSet::from([ctor.clone(), created.clone()])
-        );
-        assert!(reviewed.retired.is_empty());
-        send(&mut app, Event::Reset(ctor.clone(), false));
-        assert!(!state(&app).can_apply());
-        assert!(state(&app).presence[&created]);
-        send(&mut app, Event::Reset(ctor, true));
-        assert!(state(&app).can_apply(), "{}", errors(state(&app)));
-    }
-}
-
-#[test]
-fn invalid_literal_removal_and_unselected_scalar_buffers_are_retained_and_repairable() {
-    let (p, oa, _, _) = enum_pair();
-    let mut app = App::with_project(p);
-    start(&mut app, oa);
-    let unit = FacetSelector::Data(DataFacet::Unit);
-    decide(&mut app, unit.clone(), SemanticDecision::Candidate);
-    send(
-        &mut app,
-        Event::Input(
-            "/body/Sa/Shared/DataType/unit".into(),
-            "  untouched unit ".into(),
-        ),
-    );
-    decide(&mut app, unit.clone(), SemanticDecision::KeepTarget);
-    let retained = literal("retained");
-    decide(&mut app, retained.clone(), SemanticDecision::Candidate);
-    send(&mut app, Event::Presence(retained.clone(), false));
-    assert!(
-        !state(&app).can_apply(),
-        "Existing default must prevent removal"
-    );
-    assert!(!state(&app).presence[&retained]);
-    send(&mut app, Event::Presence(retained.clone(), true));
-    assert!(state(&app).can_apply(), "{}", errors(state(&app)));
-    assert_eq!(
-        state(&app).draft.as_ref().unwrap().inputs["/body/Sa/Shared/DataType/unit"].raw,
-        "  untouched unit "
-    );
-    decide(&mut app, unit, SemanticDecision::Candidate);
-    assert!(state(&app).can_apply(), "{}", errors(state(&app)));
-}
-
-#[test]
-fn unsupported_independent_families_and_missing_identities_do_not_gain_edit_authority() {
-    let (p, oa, _, _) = enum_pair();
-    let mut app = App::with_project(p);
-    start(&mut app, oa);
-    let unsupported = FacetSelector::Member {
-        collection: ReferenceCollection::Steps,
-        keys: KeyPair {
-            oa: Some(oa),
-            sa: None,
-        },
-    };
-    decide(&mut app, unsupported.clone(), SemanticDecision::Candidate);
-    assert!(!state(&app).decisions.contains_key(&unsupported));
-    send(&mut app, Event::MemberFamily(keyed::Family::Literal));
-    send(&mut app, Event::Literal("unpaired".into()));
-    send(&mut app, Event::LiteralSide(Layer::Sa, false));
-    send(&mut app, Event::StageMember);
-    let facet = state(&app).selected.clone().unwrap();
-    decide(&mut app, facet.clone(), SemanticDecision::Candidate);
-    assert!(!state(&app).can_apply());
-    send(&mut app, Event::LiteralSide(Layer::Oa, false));
-    send(&mut app, Event::StageMember);
-    assert!(state(&app).error.is_some());
-    assert_eq!(
-        state(&app).decisions.get(&facet),
-        Some(&SemanticDecision::Candidate)
-    );
-}
-
-#[test]
-fn deleted_member_source_observation_removes_only_mapped_membership_both_directions() {
-    for reverse in [false, true] {
-        let (mut p, oa, sa, trace, facet, locals) = member_pair(ReferenceCollection::SignalItems);
-        let FacetSelector::Member { keys, .. } = &facet else {
-            unreachable!()
-        };
-        let (source, target, deleted, local) = if reverse {
-            (sa, oa, keys.sa.unwrap(), locals[0])
-        } else {
-            (oa, sa, keys.oa.unwrap(), locals[1])
-        };
-        let target_only = FacetSelector::Member {
-            collection: ReferenceCollection::SignalItems,
-            keys: KeyPair {
-                oa: reverse.then_some(local),
-                sa: (!reverse).then_some(local),
-            },
-        };
-        put(&mut p, source, &facet, true);
-        put(&mut p, target, &facet, true);
-        put(&mut p, target, &target_only, true);
-        history(&mut p, trace, std::slice::from_ref(&facet));
-        p = prepare_command(&p, &Command::Delete(deleted))
-            .unwrap()
-            .project;
-        let mut app = App::with_project(p);
-        start(&mut app, source);
-        stage(&mut app, &facet);
-        decide(&mut app, facet.clone(), SemanticDecision::TakeSource);
-        // Force mixed final-record composition, as well as the core Take projection.
-        let name = FacetSelector::Header(HeaderFacet::Name);
-        decide(&mut app, name, SemanticDecision::Candidate);
-        assert!(state(&app).can_apply(), "{}", errors(state(&app)));
-        apply(&mut app);
-        assert!(!contains(app.project(), target, &facet, oa, sa));
-        assert!(contains(app.project(), target, &target_only, oa, sa));
-        let retained = if reverse {
-            keys.oa.unwrap()
-        } else {
-            keys.sa.unwrap()
-        };
-        assert!(app.project().elements.contains_key(&retained));
-    }
-}
-
-#[test]
-fn stale_or_source_failed_reset_and_membership_apply_retain_exact_choices() {
-    let (mut p, oa, _, trace) = enum_pair();
-    let reset = FacetSelector::Header(HeaderFacet::Name);
-    history(&mut p, trace, std::slice::from_ref(&reset));
-    let mut app = App::with_project(p.clone());
-    start(&mut app, oa);
-    send(&mut app, Event::Reset(reset.clone(), true));
-    app.document
-        .execute(Command::Rename(oa, "Changed after preview".into()))
-        .unwrap();
-    let before = app.document.snapshot();
-    apply(&mut app);
-    assert!(state(&app).error.as_ref().unwrap().contains("stale"));
-    assert!(state(&app).resets.contains(&reset));
-    assert_eq!(app.document.bundle(), &before.bundle);
-    let mut app = App::with_project(p);
-    let bundle = app.document.bundle().clone();
-    let mut limits = source_project::ProjectLimits::default();
-    limits.model.max_source_bytes = bundle.files.values().map(String::len).sum::<usize>() + 10;
-    app.document = Document::from_bundle(bundle, limits).unwrap();
-    start(&mut app, oa);
-    send(&mut app, Event::Reset(reset.clone(), true));
-    let added = literal(&" exact long literal ".repeat(100));
-    stage(&mut app, &added);
-    decide(&mut app, added.clone(), SemanticDecision::Candidate);
-    send(&mut app, Event::Presence(added.clone(), true));
-    assert!(state(&app).can_apply(), "{}", errors(state(&app)));
-    let before = app.document.snapshot();
-    apply(&mut app);
-    assert!(state(&app).error.is_some());
-    assert!(state(&app).resets.contains(&reset));
-    assert_eq!(
-        state(&app).decisions.get(&added),
-        Some(&SemanticDecision::Candidate)
-    );
-    assert!(state(&app).presence[&added]);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert!(!app.document.can_undo());
-}
-
-#[test]
-fn member_identity_labels_and_new_tabs_preserve_exact_names_and_deleted_keys() {
-    let (mut p, oa, _, trace, facet, _) = member_pair(ReferenceCollection::SignalItems);
-    let FacetSelector::Member { collection, keys } = &facet else {
-        unreachable!()
-    };
-    p.elements.get_mut(&keys.oa.unwrap()).unwrap().name = "Absent intentionally in name".into();
-    let name = view::title(&p, &facet);
-    assert!(name.contains("Absent intentionally in name"));
-    let deleted1 = Id::new_v4();
-    let deleted2 = Id::new_v4();
-    let old1 = FacetSelector::Member {
-        collection: *collection,
-        keys: KeyPair {
-            oa: Some(deleted1),
-            sa: None,
-        },
-    };
-    let old2 = FacetSelector::Member {
-        collection: *collection,
-        keys: KeyPair {
-            oa: Some(deleted2),
-            sa: None,
-        },
-    };
-    history(&mut p, trace, &[old1.clone(), old2.clone()]);
-    assert!(view::title(&p, &old1).contains(&deleted1.to_string()));
-    assert_ne!(view::title(&p, &old1), view::title(&p, &old2));
-    assert_ne!(
-        view::title(&p, &literal("Absent")),
-        view::title(
-            &p,
-            &FacetSelector::Literal(KeyPair {
-                oa: None,
-                sa: Some("Absent".into())
-            })
-        )
-    );
-    let mut app = App::with_project(p);
-    start(&mut app, oa);
-    for tab in [Tab::History, Tab::Members, Tab::Facts] {
-        send(&mut app, Event::Tab(tab));
-        let _ = state(&app).view(app.project());
-    }
-    send(&mut app, Event::Reset(old1.clone(), true));
-    assert!(state(&app).can_apply(), "{}", errors(state(&app)));
-    assert!(!state(&app).facts.iter().any(|f| f.selector == old1));
-    assert!(state(&app).facts.iter().any(|f| f.selector == old2));
-}
-
-#[test]
-fn staging_removal_and_obsolete_reset_recovery_keep_other_decisions_and_raw_presence() {
-    let (mut p, oa, _, trace) = enum_pair();
-    let reset = FacetSelector::Header(HeaderFacet::Name);
-    history(&mut p, trace, std::slice::from_ref(&reset));
-    let mut app = App::with_project(p.clone());
-    start(&mut app, oa);
-    send(&mut app, Event::Reset(reset.clone(), true));
-    let added = literal("staged draft");
-    stage(&mut app, &added);
-    decide(&mut app, added.clone(), SemanticDecision::Candidate);
-    send(&mut app, Event::Presence(added.clone(), true));
-    send(&mut app, Event::DropStaged(added.clone()));
-    assert!(state(&app).decisions.is_empty());
-    assert!(!state(&app).staged.contains(&added));
-    assert!(state(&app).presence[&added]);
-    assert!(state(&app).can_apply());
-    stage(&mut app, &added);
-    decide(&mut app, added.clone(), SemanticDecision::Candidate);
-    assert!(state(&app).presence[&added]);
-    p.traces
-        .get_mut(&trace)
-        .unwrap()
-        .baseline
-        .as_mut()
-        .unwrap()
-        .semantic
-        .as_mut()
-        .unwrap()
-        .facets
-        .clear();
-    let crate::workflow::Workflow::Semantic(s) = app.workflow.as_mut().unwrap() else {
-        unreachable!()
-    };
-    s.refresh(&p);
-    assert!(!s.can_apply());
-    s.tab = Tab::History;
-    let _ = s.view(&p);
-    s.update(&p, Event::Reset(reset, false));
-    assert!(s.can_apply(), "{}", errors(s));
-    assert_eq!(s.decisions.get(&added), Some(&SemanticDecision::Candidate));
-}

crates/oa-desktop/src/semantic_review/message_kind.rs

@@ -1,24 +0,0 @@
-//! The first supported constructor group is the closed nested MessageKind.
-//! The core owns its acknowledgment/retirement and validation policies.
-use super::*;
-
-pub(super) fn selector() -> FacetSelector {
-    FacetSelector::Occurrence(OccurrenceFacet::MessageKind)
-}
-#[cfg(test)]
-pub(super) fn timer_selector() -> FacetSelector {
-    FacetSelector::Occurrence(OccurrenceFacet::TimerExpression)
-}
-pub(super) fn handles(facet: &FacetSelector) -> bool {
-    *facet == selector()
-}
-#[cfg(test)]
-pub(super) fn value(project: &Project, id: Id) -> Option<&MessageKind> {
-    match project.elements.get(&id)?.shared()? {
-        SharedBody::Occurrence {
-            body: OccurrenceBody::Exchange { message_kind, .. },
-            ..
-        } => Some(message_kind),
-        _ => None,
-    }
-}

crates/oa-desktop/src/semantic_review/message_kind_tests.rs

@@ -1,717 +0,0 @@
-use super::{tests::*, *};
-use crate::{app::App, document::Document};
-use serde_json::json;
-
-fn fixture(oa_kind: MessageKind, sa_kind: MessageKind) -> (Project, Id, Id, Id) {
-    let mut p = Project::empty();
-    let mut ids = vec![];
-    for (layer, message_kind) in [(Layer::Oa, oa_kind), (Layer::Sa, sa_kind)] {
-        let scenario = p
-            .add_element(Kind::Scenario, layer, "Scenario", None)
-            .unwrap();
-        let id = p
-            .add_element(Kind::Occurrence, layer, "Message", Some(scenario))
-            .unwrap();
-        *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::Occurrence {
-            body: OccurrenceBody::Exchange {
-                exchange: None,
-                sender: None,
-                receiver: None,
-                message_kind,
-                reply_to: None,
-                values: vec![],
-            },
-            precondition: "retain precondition".into(),
-            postcondition: "retain postcondition".into(),
-        };
-        p.elements
-            .get_mut(&scenario)
-            .unwrap()
-            .steps_mut()
-            .unwrap()
-            .push(id);
-        ids.push(id);
-    }
-    let trace = add_trace(&mut p, ids[0], ids[1], "Message-kind review");
-    (p, ids[0], ids[1], trace)
-}
-fn timer(value: &str) -> MessageKind {
-    MessageKind::Timer {
-        expression: value.into(),
-    }
-}
-fn path(layer: &str) -> String {
-    format!("/body/{layer}/Shared/Occurrence/body/Exchange/message_kind")
-}
-fn set_kind(p: &mut Project, id: Id, kind: MessageKind) {
-    let Some(SharedBody::Occurrence {
-        body: OccurrenceBody::Exchange { message_kind, .. },
-        ..
-    }) = p.elements.get_mut(&id).unwrap().shared_mut()
-    else {
-        panic!()
-    };
-    *message_kind = kind;
-}
-fn seed_history(p: &mut Project, trace: Id) {
-    let t = &p.traces[&trace];
-    let baseline = TraceBaseline {
-        oa: p.properties(t.oa).unwrap(),
-        sa: p.properties(t.sa).unwrap(),
-        semantic: Some(SemanticBaseline {
-            facets: [message_kind::selector(), message_kind::timer_selector()]
-                .iter()
-                .map(|selector| capture_facet(p, t.oa, t.sa, selector).unwrap())
-                .collect(),
-        }),
-    };
-    p.traces.get_mut(&trace).unwrap().baseline = Some(baseline);
-}
-fn acknowledged(app: &App) -> BTreeSet<FacetSelector> {
-    state(app).plan.as_ref().unwrap().reviews[0]
-        .acknowledged
-        .iter()
-        .cloned()
-        .collect()
-}
-fn failures(app: &App) -> String {
-    state(app)
-        .error
-        .iter()
-        .chain(state(app).plan.iter().flat_map(|p| &p.conflicts))
-        .cloned()
-        .collect::<Vec<_>>()
-        .join("; ")
-}
-
-#[test]
-fn message_group_take_full_timer_and_scalar_candidate_are_one_source_history_change_both_directions()
- {
-    for reverse in [false, true] {
-        let expression = "  after β ≥ 5 s\n\tkeep exact whitespace  ";
-        let (p, oa, sa, trace) = if reverse {
-            fixture(MessageKind::Asynchronous, timer(expression))
-        } else {
-            fixture(timer(expression), MessageKind::Asynchronous)
-        };
-        let (source, target) = if reverse { (sa, oa) } else { (oa, sa) };
-        let mut app = App::with_project(p);
-        let mut bundle = app.document.bundle().clone();
-        bundle
-            .files
-            .get_mut(&bundle.entry)
-            .unwrap()
-            .insert_str(0, "// Keep the engineering review rationale.\r\n");
-        app.document.apply_bundle(bundle).unwrap();
-        let before = app.document.snapshot();
-        let revision = app.document.revision();
-        start(&mut app, source);
-        decide(
-            &mut app,
-            message_kind::selector(),
-            SemanticDecision::TakeSource,
-        );
-        decide(
-            &mut app,
-            FacetSelector::Header(HeaderFacet::Name),
-            SemanticDecision::Candidate,
-        );
-        send(
-            &mut app,
-            Event::Input("/name".into(), "Reviewed message".into()),
-        );
-        assert!(state(&app).can_apply(), "{:?}", state(&app).error);
-        assert_eq!(
-            acknowledged(&app),
-            BTreeSet::from([
-                message_kind::selector(),
-                message_kind::timer_selector(),
-                FacetSelector::Header(HeaderFacet::Name)
-            ])
-        );
-        assert!(
-            state(&app).plan.as_ref().unwrap().reviews[0]
-                .retired
-                .is_empty()
-        );
-        assert!(state(&app).plan.as_ref().unwrap().impacts.is_empty());
-        let expected = state(&app).proposed.clone().unwrap();
-        assert_eq!(
-            message_kind::value(&expected, target),
-            Some(&timer(expression))
-        );
-        assert_eq!(app.document.bundle(), &before.bundle);
-        apply(&mut app);
-        assert_eq!(app.project(), &expected);
-        assert_eq!(app.document.revision(), revision + 1);
-        assert_eq!(
-            app.project().elements[&source],
-            before.decoded.project.elements[&source]
-        );
-        let saved = app.document.bundle().clone();
-        assert!(saved.files[&saved.entry].starts_with("// Keep the engineering review rationale."));
-        assert_eq!(
-            Document::from_bundle(saved.clone(), source_project::ProjectLimits::default())
-                .unwrap()
-                .snapshot()
-                .decoded
-                .project,
-            expected
-        );
-        let facts = &app.project().traces[&trace]
-            .baseline
-            .as_ref()
-            .unwrap()
-            .semantic
-            .as_ref()
-            .unwrap()
-            .facets;
-        assert_eq!(facts.len(), 3);
-        let _ = app.update(Message::Undo);
-        assert_eq!(app.document.bundle(), &before.bundle);
-        let _ = app.update(Message::Redo);
-        assert_eq!(app.document.bundle(), &saved);
-    }
-}
-
-#[test]
-fn message_group_candidate_timer_switches_preserve_both_drafts_and_overlap_is_explicit() {
-    let (p, oa, _, _) = fixture(MessageKind::Asynchronous, timer("original target"));
-    let mut app = App::with_project(p);
-    let before = app.document.snapshot();
-    let kind = path("Sa");
-    let expression = format!("{kind}/Timer/expression");
-    start(&mut app, oa);
-    decide(
-        &mut app,
-        message_kind::timer_selector(),
-        SemanticDecision::Candidate,
-    );
-    send(
-        &mut app,
-        Event::Input(expression.clone(), "independent scalar timer".into()),
-    );
-    decide(
-        &mut app,
-        message_kind::selector(),
-        SemanticDecision::Candidate,
-    );
-    assert_eq!(state(&app).decisions.len(), 2);
-    assert!(!state(&app).can_apply());
-    send(
-        &mut app,
-        Event::Input(expression.clone(), "  group β timer\n\t  ".into()),
-    );
-    send(
-        &mut app,
-        Event::Text(expression.clone(), text_editor::Action::SelectAll),
-    );
-    let cursor = state(&app)
-        .group_drafts
-        .get(&message_kind::selector())
-        .unwrap()
-        .inputs[&expression]
-        .editor
-        .cursor();
-    let selection = state(&app)
-        .group_drafts
-        .get(&message_kind::selector())
-        .unwrap()
-        .inputs[&expression]
-        .editor
-        .selection();
-    send(
-        &mut app,
-        Event::Variant(kind.clone(), json!("Asynchronous")),
-    );
-    send(
-        &mut app,
-        Event::Variant(kind, json!({"Timer":{"expression":""}})),
-    );
-    assert_eq!(
-        state(&app)
-            .group_drafts
-            .get(&message_kind::selector())
-            .unwrap()
-            .inputs[&expression]
-            .raw,
-        "  group β timer\n\t  "
-    );
-    assert_eq!(
-        state(&app)
-            .group_drafts
-            .get(&message_kind::selector())
-            .unwrap()
-            .inputs[&expression]
-            .editor
-            .cursor(),
-        cursor
-    );
-    assert_eq!(
-        state(&app)
-            .group_drafts
-            .get(&message_kind::selector())
-            .unwrap()
-            .inputs[&expression]
-            .editor
-            .selection(),
-        selection
-    );
-    assert_eq!(
-        state(&app).draft.as_ref().unwrap().inputs[&expression].raw,
-        "independent scalar timer"
-    );
-    assert!(!state(&app).can_apply());
-    assert_eq!(app.document.bundle(), &before.bundle);
-    // The visible overlap-resolution actions only change the explicitly chosen
-    // decision. Neither independent candidate buffer is discarded.
-    send(&mut app, Event::Decide(message_kind::selector(), None));
-    assert!(state(&app).can_apply());
-    send(
-        &mut app,
-        Event::Decide(message_kind::timer_selector(), None),
-    );
-    decide(
-        &mut app,
-        message_kind::selector(),
-        SemanticDecision::Candidate,
-    );
-    assert!(state(&app).can_apply(), "{:?}", state(&app).error);
-    assert_eq!(
-        acknowledged(&app),
-        BTreeSet::from([message_kind::selector(), message_kind::timer_selector()])
-    );
-    let _ = state(&app).view(app.project());
-    let expected = state(&app).proposed.clone().unwrap();
-    apply(&mut app);
-    assert_eq!(app.project(), &expected);
-}
-
-#[test]
-fn message_group_keep_historical_switch_retires_timer_and_completed_no_switch_rejects() {
-    let (mut p, oa, sa, trace) = fixture(timer("old OA"), timer("old SA"));
-    seed_history(&mut p, trace);
-    set_kind(&mut p, oa, MessageKind::Asynchronous);
-    set_kind(&mut p, sa, MessageKind::Asynchronous);
-    let mut app = App::with_project(p);
-    start(&mut app, oa);
-    decide(
-        &mut app,
-        message_kind::selector(),
-        SemanticDecision::KeepTarget,
-    );
-    assert!(state(&app).can_apply(), "{:?}", state(&app).error);
-    assert_eq!(
-        acknowledged(&app),
-        BTreeSet::from([message_kind::selector()])
-    );
-    assert_eq!(
-        state(&app).plan.as_ref().unwrap().reviews[0].retired,
-        vec![message_kind::timer_selector()]
-    );
-    apply(&mut app);
-    assert_eq!(
-        app.project().traces[&trace]
-            .baseline
-            .as_ref()
-            .unwrap()
-            .semantic
-            .as_ref()
-            .unwrap()
-            .facets
-            .len(),
-        1
-    );
-    start(&mut app, oa);
-    decide(
-        &mut app,
-        message_kind::selector(),
-        SemanticDecision::KeepTarget,
-    );
-    assert!(!state(&app).can_apply());
-    assert!(
-        failures(&app).contains("No constructor switch"),
-        "{}",
-        failures(&app)
-    );
-}
-
-#[test]
-fn message_group_reply_and_reference_take_require_explicit_call_mapping_both_directions() {
-    for reverse in [false, true] {
-        let (mut p, oa, sa, _) = if reverse {
-            fixture(MessageKind::Asynchronous, MessageKind::Reply)
-        } else {
-            fixture(MessageKind::Reply, MessageKind::Asynchronous)
-        };
-        let (source, target, layer) = if reverse {
-            (sa, oa, "Oa")
-        } else {
-            (oa, sa, "Sa")
-        };
-        let mut calls = vec![];
-        for message in [oa, sa] {
-            let scenario = p.elements[&message].parent.unwrap();
-            let layer = p.elements[&message].layer();
-            let call = p
-                .add_element(Kind::Occurrence, layer, "Correlated call", Some(scenario))
-                .unwrap();
-            *p.elements.get_mut(&call).unwrap().shared_mut().unwrap() = SharedBody::Occurrence {
-                body: OccurrenceBody::Exchange {
-                    exchange: None,
-                    sender: None,
-                    receiver: None,
-                    message_kind: MessageKind::Call,
-                    reply_to: None,
-                    values: vec![],
-                },
-                precondition: String::new(),
-                postcondition: String::new(),
-            };
-            p.elements
-                .get_mut(&scenario)
-                .unwrap()
-                .steps_mut()
-                .unwrap()
-                .insert(0, call);
-            if message == source {
-                let Some(SharedBody::Occurrence {
-                    body: OccurrenceBody::Exchange { reply_to, .. },
-                    ..
-                }) = p.elements.get_mut(&message).unwrap().shared_mut()
-                else {
-                    panic!()
-                };
-                *reply_to = Some(call);
-            }
-            calls.push(call);
-        }
-        let target_call = if reverse { calls[0] } else { calls[1] };
-        let mut app = App::with_project(p);
-        let before = app.document.snapshot();
-        start(&mut app, source);
-        decide(
-            &mut app,
-            message_kind::selector(),
-            SemanticDecision::Candidate,
-        );
-        send(&mut app, Event::Variant(path(layer), json!("Reply")));
-        decide(
-            &mut app,
-            FacetSelector::Occurrence(OccurrenceFacet::ReplyTo),
-            SemanticDecision::TakeSource,
-        );
-        assert!(!state(&app).can_apply());
-        assert!(
-            failures(&app).contains("reference counterparts"),
-            "{}",
-            failures(&app)
-        );
-        send(
-            &mut app,
-            Event::ReferenceOa(Choice {
-                id: calls[0],
-                label: "OA call".into(),
-            }),
-        );
-        send(
-            &mut app,
-            Event::ReferenceSa(Choice {
-                id: calls[1],
-                label: "SA call".into(),
-            }),
-        );
-        send(&mut app, Event::AddReference);
-        assert!(state(&app).can_apply(), "{}", failures(&app));
-        assert_eq!(
-            acknowledged(&app),
-            BTreeSet::from([
-                message_kind::selector(),
-                FacetSelector::Occurrence(OccurrenceFacet::ReplyTo)
-            ])
-        );
-        let final_value =
-            serde_json::to_value(&state(&app).proposed.as_ref().unwrap().elements[&target])
-                .unwrap();
-        assert_eq!(
-            final_value.pointer(&format!(
-                "/body/{layer}/Shared/Occurrence/body/Exchange/reply_to"
-            )),
-            Some(&json!(target_call))
-        );
-        assert_eq!(app.document.bundle(), &before.bundle);
-        apply(&mut app);
-        assert_eq!(
-            message_kind::value(app.project(), target),
-            Some(&MessageKind::Reply)
-        );
-        for call in calls {
-            assert_eq!(
-                app.project().elements[&call],
-                before.decoded.project.elements[&call]
-            );
-        }
-    }
-}
-
-#[test]
-fn message_group_candidate_closed_kinds_are_core_validated_in_both_directions() {
-    for reverse in [false, true] {
-        for kind in [
-            MessageKind::Asynchronous,
-            MessageKind::Call,
-            MessageKind::Reply,
-            MessageKind::Create,
-            MessageKind::Delete,
-            timer("after 2 s"),
-        ] {
-            let (p, oa, sa, _) = fixture(MessageKind::Asynchronous, MessageKind::Asynchronous);
-            let (source, target, layer) = if reverse {
-                (sa, oa, "Oa")
-            } else {
-                (oa, sa, "Sa")
-            };
-            let mut app = App::with_project(p);
-            start(&mut app, source);
-            decide(
-                &mut app,
-                message_kind::selector(),
-                SemanticDecision::Candidate,
-            );
-            send(
-                &mut app,
-                Event::Variant(path(layer), serde_json::to_value(&kind).unwrap()),
-            );
-            assert!(state(&app).can_apply(), "{kind:?}: {}", failures(&app));
-            assert_eq!(
-                message_kind::value(state(&app).proposed.as_ref().unwrap(), target),
-                Some(&kind)
-            );
-            assert_eq!(
-                acknowledged(&app).contains(&message_kind::timer_selector()),
-                matches!(kind, MessageKind::Timer { .. })
-            );
-            assert!(state(&app).plan.as_ref().unwrap().impacts.is_empty());
-        }
-    }
-    let (mut p, oa, _, _) = fixture(MessageKind::Asynchronous, MessageKind::Asynchronous);
-    let mut review = State::new(&p, oa).unwrap();
-    let Some(SharedBody::Occurrence { body, .. }) = p.elements.get_mut(&oa).unwrap().shared_mut()
-    else {
-        panic!()
-    };
-    *body = OccurrenceBody::Action {
-        action: None,
-        lifeline: None,
-    };
-    review.refresh(&p);
-    assert!(
-        !review.editable(&p, &message_kind::selector()),
-        "An externally changed outer occurrence requires its own constructor review"
-    );
-    review.update(
-        &p,
-        Event::Decide(message_kind::selector(), Some(SemanticDecision::Candidate)),
-    );
-    assert!(review.decisions.is_empty());
-    assert!(!review.can_apply());
-}
-
-#[test]
-fn message_group_timer_does_not_erase_exchange_without_its_own_selected_decision() {
-    let (mut p, oa, sa, _) = fixture(MessageKind::Asynchronous, MessageKind::Asynchronous);
-    let sender = p
-        .add_element(Kind::Function, Layer::Sa, "Sender", None)
-        .unwrap();
-    let receiver = p
-        .add_element(Kind::Function, Layer::Sa, "Receiver", None)
-        .unwrap();
-    let exchange = p.relate(
-        RelationKind::FunctionalExchange,
-        "Message exchange",
-        sender,
-        receiver,
-    );
-    let Some(SharedBody::Occurrence {
-        body: OccurrenceBody::Exchange {
-            exchange: selected, ..
-        },
-        ..
-    }) = p.elements.get_mut(&sa).unwrap().shared_mut()
-    else {
-        panic!()
-    };
-    *selected = Some(exchange);
-    let mut app = App::with_project(p);
-    let before = app.document.snapshot();
-    start(&mut app, oa);
-    decide(
-        &mut app,
-        message_kind::selector(),
-        SemanticDecision::Candidate,
-    );
-    send(
-        &mut app,
-        Event::Variant(path("Sa"), json!({"Timer":{"expression":"after 2 s"}})),
-    );
-    assert!(!state(&app).can_apply());
-    assert!(
-        failures(&app).contains("timer_contract"),
-        "{}",
-        failures(&app)
-    );
-    assert_eq!(state(&app).decisions.len(), 1);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    decide(
-        &mut app,
-        FacetSelector::Occurrence(OccurrenceFacet::Exchange),
-        SemanticDecision::Candidate,
-    );
-    send(
-        &mut app,
-        Event::Shape(
-            "/body/Sa/Shared/Occurrence/body/Exchange/exchange".into(),
-            Value::Null,
-        ),
-    );
-    assert!(state(&app).can_apply(), "{}", failures(&app));
-    assert_eq!(
-        acknowledged(&app),
-        BTreeSet::from([
-            message_kind::selector(),
-            message_kind::timer_selector(),
-            FacetSelector::Occurrence(OccurrenceFacet::Exchange)
-        ])
-    );
-    assert!(state(&app).plan.as_ref().unwrap().impacts.is_empty());
-    apply(&mut app);
-    assert_eq!(
-        app.project().relations[&exchange],
-        before.decoded.project.relations[&exchange]
-    );
-}
-
-#[test]
-fn message_group_initial_equal_take_acknowledges_only_kind_and_checks_authored_timer_agreement() {
-    let (p, oa, sa, _) = fixture(timer("source timer"), timer("target timer"));
-    let mut app = App::with_project(p);
-    start(&mut app, oa);
-    decide(
-        &mut app,
-        message_kind::selector(),
-        SemanticDecision::TakeSource,
-    );
-    decide(
-        &mut app,
-        FacetSelector::Header(HeaderFacet::Name),
-        SemanticDecision::Candidate,
-    );
-    send(&mut app, Event::Input("/name".into(), "Final name".into()));
-    assert!(state(&app).can_apply(), "{:?}", state(&app).error);
-    assert_eq!(
-        message_kind::value(state(&app).proposed.as_ref().unwrap(), sa),
-        Some(&timer("target timer"))
-    );
-    assert!(!acknowledged(&app).contains(&message_kind::timer_selector()));
-    let expression = format!("{}/Timer/expression", path("Sa"));
-    decide(
-        &mut app,
-        message_kind::selector(),
-        SemanticDecision::Candidate,
-    );
-    send(
-        &mut app,
-        Event::Input(expression.clone(), "authored group timer".into()),
-    );
-    assert!(
-        !state(&app).can_apply(),
-        "An unchanged initial kind cannot silently authorize a timer edit"
-    );
-    decide(
-        &mut app,
-        message_kind::timer_selector(),
-        SemanticDecision::Candidate,
-    );
-    send(
-        &mut app,
-        Event::Input(expression.clone(), "different scalar timer".into()),
-    );
-    assert!(!state(&app).can_apply());
-    assert!(
-        state(&app)
-            .error
-            .as_ref()
-            .unwrap()
-            .contains("different final values")
-    );
-    send(
-        &mut app,
-        Event::Input(expression, "authored group timer".into()),
-    );
-    assert!(state(&app).can_apply(), "{:?}", state(&app).error);
-    assert!(acknowledged(&app).contains(&message_kind::timer_selector()));
-    assert_eq!(
-        message_kind::value(state(&app).proposed.as_ref().unwrap(), sa),
-        Some(&timer("authored group timer"))
-    );
-}
-
-#[test]
-fn message_group_rejects_protected_edits_stale_plan_and_source_failure_without_losing_timer() {
-    for source_failure in [false, true] {
-        let (p, oa, _, _) = fixture(MessageKind::Asynchronous, timer("target"));
-        let mut app = App::with_project(p);
-        if source_failure {
-            let bundle = app.document.bundle().clone();
-            let mut limits = source_project::ProjectLimits::default();
-            limits.model.max_source_bytes =
-                bundle.files.values().map(String::len).sum::<usize>() + 10;
-            app.document = Document::from_bundle(bundle, limits).unwrap();
-        }
-        start(&mut app, oa);
-        decide(
-            &mut app,
-            message_kind::selector(),
-            SemanticDecision::Candidate,
-        );
-        let expression = format!("{}/Timer/expression", path("Sa"));
-        let raw = "retain exact timer β\n".repeat(40);
-        send(&mut app, Event::Input(expression.clone(), raw.clone()));
-        assert!(state(&app).can_apply(), "{:?}", state(&app).error);
-        send(
-            &mut app,
-            Event::Input("/name".into(), "Unselected protected scope".into()),
-        );
-        assert!(!state(&app).can_apply());
-        assert!(
-            state(&app)
-                .error
-                .as_ref()
-                .unwrap()
-                .contains("selected review")
-        );
-        send(&mut app, Event::Preview);
-        assert!(state(&app).can_apply());
-        if !source_failure {
-            app.document
-                .execute(Command::Rename(oa, "External source edit".into()))
-                .unwrap();
-        }
-        let before = app.document.snapshot();
-        let revision = app.document.revision();
-        apply(&mut app);
-        assert!(state(&app).error.is_some());
-        assert_eq!(state(&app).decisions.len(), 1);
-        assert_eq!(
-            state(&app)
-                .group_drafts
-                .get(&message_kind::selector())
-                .unwrap()
-                .inputs[&expression]
-                .raw,
-            raw
-        );
-        assert_eq!(app.document.bundle(), &before.bundle);
-        assert_eq!(app.document.revision(), revision);
-    }
-}

crates/oa-desktop/src/semantic_review/scalar.rs

@@ -1,288 +0,0 @@
-//! Fixed typed scalar bindings for property forms. Core validates every result.
-use oa_core::*;
-use serde_json::Value;
-use std::collections::{BTreeMap, BTreeSet};
-struct Own {
-    whole: Value,
-    prefix: Vec<String>,
-    kind: String,
-}
-fn enum_tag(value: &Value) -> Option<&str> {
-    value.as_str().or_else(|| {
-        value
-            .as_object()
-            .and_then(|v| v.keys().next().map(String::as_str))
-    })
-}
-impl Own {
-    fn get(project: &Project, id: Id) -> Option<Self> {
-        let (whole, element) = if let Some(e) = project.elements.get(&id) {
-            (serde_json::to_value(e).ok()?, true)
-        } else {
-            (
-                serde_json::to_value(project.relations.get(&id)?).ok()?,
-                false,
-            )
-        };
-        let mut prefix = vec!["body".to_string()];
-        let mut value = &whole["body"];
-        if element {
-            let layer = enum_tag(value)?.to_string();
-            prefix.push(layer.clone());
-            value = &value[&layer];
-            if enum_tag(value) == Some("Shared") {
-                prefix.push("Shared".into());
-                value = &value["Shared"];
-            }
-        }
-        let kind = enum_tag(value)?.to_string();
-        prefix.push(kind.clone());
-        Some(Self {
-            whole,
-            prefix,
-            kind,
-        })
-    }
-}
-fn at<'a>(mut value: &'a Value, path: &[String]) -> Option<&'a Value> {
-    for part in path {
-        value = value.get(part)?;
-    }
-    Some(value)
-}
-fn path(own: &Own, facet: &FacetSelector) -> Option<Vec<String>> {
-    use FacetSelector as F;
-    let (family, parts): (&str, &[&str]) = match facet {
-        F::Header(HeaderFacet::Name) => return Some(vec!["name".into()]),
-        F::Header(HeaderFacet::Description) => return Some(vec!["description".into()]),
-        F::Header(HeaderFacet::Parent) => {
-            return own.whole.get("parent").map(|_| vec!["parent".into()]);
-        }
-        F::ExchangeItem(ExchangeItemFacet::Nature) => ("ExchangeItem", &["kind"]),
-        F::ExchangeItem(ExchangeItemFacet::Mechanism) => ("ExchangeItem", &["mechanism"]),
-        F::ExchangeItem(ExchangeItemFacet::Supertype) => ("ExchangeItem", &["supertype"]),
-        F::Interface(InterfaceFacet::Supertype) => ("Interface", &["supertype"]),
-        F::Data(DataFacet::Constructor) => ("DataType", &["definition"]),
-        F::Data(DataFacet::IntegerMinimum) => ("DataType", &["definition", "Integer", "minimum"]),
-        F::Data(DataFacet::IntegerMaximum) => ("DataType", &["definition", "Integer", "maximum"]),
-        F::Data(DataFacet::RealMinimum) => ("DataType", &["definition", "Real", "minimum"]),
-        F::Data(DataFacet::RealMaximum) => ("DataType", &["definition", "Real", "maximum"]),
-        F::Data(DataFacet::StringMinimumLength) => {
-            ("DataType", &["definition", "String", "minimum_length"])
-        }
-        F::Data(DataFacet::StringMaximumLength) => {
-            ("DataType", &["definition", "String", "maximum_length"])
-        }
-        F::Data(DataFacet::RecordSupertype) => ("DataType", &["definition", "Record", "supertype"]),
-        F::Data(DataFacet::Default) => ("DataType", &["default"]),
-        F::Data(DataFacet::Unit) => ("DataType", &["unit"]),
-        F::Field(FieldFacet::Type) => ("DataField", &["type_ref"]),
-        F::Field(FieldFacet::Minimum) => ("DataField", &["minimum"]),
-        F::Field(FieldFacet::Maximum) => ("DataField", &["maximum"]),
-        F::Field(FieldFacet::Unit) => ("DataField", &["unit"]),
-        F::Field(FieldFacet::Direction) => ("DataField", &["direction"]),
-        F::Field(FieldFacet::Storage) => ("DataField", &["storage"]),
-        F::Field(FieldFacet::Default) => ("DataField", &["default"]),
-        F::Port(PortFacet::Constructor) => ("Port", &["contract"]),
-        F::Port(PortFacet::ComponentKind) => ("Port", &["contract", "Component", "kind"]),
-        F::Port(PortFacet::Orientation) => ("Port", &["contract", "Component", "orientation"]),
-        F::Port(PortFacet::LegacyDirection) => ("Port", &["legacy", "direction"]),
-        F::Port(PortFacet::LegacyInterface) => ("Port", &["legacy", "interface"]),
-        F::Scenario(ScenarioFacet::Viewpoint) => ("Scenario", &["viewpoint"]),
-        F::Scenario(ScenarioFacet::Context) => ("Scenario", &["context"]),
-        F::Scenario(ScenarioFacet::Precondition) => ("Scenario", &["precondition"]),
-        F::Scenario(ScenarioFacet::Postcondition) => ("Scenario", &["postcondition"]),
-        F::Lifeline(LifelineFacet::Represented) => ("Lifeline", &["represented"]),
-        F::Occurrence(OccurrenceFacet::Constructor) => ("Occurrence", &["body"]),
-        F::Occurrence(OccurrenceFacet::Precondition) => ("Occurrence", &["precondition"]),
-        F::Occurrence(OccurrenceFacet::Postcondition) => ("Occurrence", &["postcondition"]),
-        F::Occurrence(OccurrenceFacet::Exchange) => {
-            ("Occurrence", &["body", "Exchange", "exchange"])
-        }
-        F::Occurrence(OccurrenceFacet::Sender) => ("Occurrence", &["body", "Exchange", "sender"]),
-        F::Occurrence(OccurrenceFacet::Receiver) => {
-            ("Occurrence", &["body", "Exchange", "receiver"])
-        }
-        F::Occurrence(OccurrenceFacet::MessageKind) => {
-            ("Occurrence", &["body", "Exchange", "message_kind"])
-        }
-        F::Occurrence(OccurrenceFacet::TimerExpression) => (
-            "Occurrence",
-            &["body", "Exchange", "message_kind", "Timer", "expression"],
-        ),
-        F::Occurrence(OccurrenceFacet::ReplyTo) => {
-            ("Occurrence", &["body", "Exchange", "reply_to"])
-        }
-        F::Occurrence(OccurrenceFacet::Action) => ("Occurrence", &["body", "Action", "action"]),
-        F::Occurrence(OccurrenceFacet::ActionLifeline) => {
-            ("Occurrence", &["body", "Action", "lifeline"])
-        }
-        F::Occurrence(OccurrenceFacet::ControlKind) => ("Occurrence", &["body", "Control", "kind"]),
-        F::Occurrence(OccurrenceFacet::Sequence) => {
-            ("Occurrence", &["body", "SequenceReference", "sequence"])
-        }
-        F::Occurrence(OccurrenceFacet::Scenario) => {
-            ("Occurrence", &["body", "ScenarioUse", "scenario"])
-        }
-        F::Occurrence(OccurrenceFacet::State) => ("Occurrence", &["body", "State", "state"]),
-        F::Occurrence(OccurrenceFacet::StateLifeline) => {
-            ("Occurrence", &["body", "State", "lifeline"])
-        }
-        F::Occurrence(OccurrenceFacet::FragmentOperator) => {
-            ("Occurrence", &["body", "Fragment", "operator"])
-        }
-        F::Occurrence(OccurrenceFacet::BranchGuard) => ("Occurrence", &["body", "Branch", "guard"]),
-        F::Event(EventFacet::Constructor) => ("Event", &["body"]),
-        F::Event(EventFacet::TimeKind) => ("Event", &["body", "Time", "kind"]),
-        F::Event(EventFacet::TimeExpression) => ("Event", &["body", "Time", "expression"]),
-        F::Event(EventFacet::ChangeExpression) => ("Event", &["body", "Change", "expression"]),
-        F::State(StateFacet::Kind) => ("State", &["kind"]),
-        F::State(StateFacet::Entry) => ("State", &["entry"]),
-        F::State(StateFacet::Exit) => ("State", &["exit"]),
-        F::State(StateFacet::DoActivity) => ("State", &["do_activity"]),
-        F::Constraint(ConstraintFacet::Expression) => ("Constraint", &["expression"]),
-        F::Relation(RelationFacet::Source) => ("*", &["source"]),
-        F::Relation(RelationFacet::Target) => ("*", &["target"]),
-        F::Relation(RelationFacet::AllocationOrder) => ("InterfaceItemAllocation", &["order"]),
-        F::Relation(RelationFacet::Transmission) => ("InterfaceItemAllocation", &["transmission"]),
-        F::Relation(RelationFacet::Acquisition) => ("InterfaceItemAllocation", &["acquisition"]),
-        F::Relation(RelationFacet::SourceRole) => ("DataAssociation", &["source_role"]),
-        F::Relation(RelationFacet::TargetRole) => ("DataAssociation", &["target_role"]),
-        F::Relation(RelationFacet::SourceMinimum) => ("DataAssociation", &["source_minimum"]),
-        F::Relation(RelationFacet::SourceMaximum) => ("DataAssociation", &["source_maximum"]),
-        F::Relation(RelationFacet::TargetMinimum) => ("DataAssociation", &["target_minimum"]),
-        F::Relation(RelationFacet::TargetMaximum) => ("DataAssociation", &["target_maximum"]),
-        F::Relation(RelationFacet::SourceNavigable) => ("DataAssociation", &["source_navigable"]),
-        F::Relation(RelationFacet::TargetNavigable) => ("DataAssociation", &["target_navigable"]),
-        F::Relation(RelationFacet::SourcePort) => ("FunctionalExchange", &["source_port"]),
-        F::Relation(RelationFacet::TargetPort) => ("FunctionalExchange", &["target_port"]),
-        F::Relation(RelationFacet::Oriented) => ("BoundaryExchange", &["oriented"]),
-        F::Relation(RelationFacet::ExtendCondition) => ("CapabilityExtend", &["condition"]),
-        F::Relation(RelationFacet::SequenceGuard) => ("SequenceLink", &["guard"]),
-        F::Relation(RelationFacet::TransitionKind) => ("StateTransition", &["transition_kind"]),
-        F::Relation(RelationFacet::Trigger) => ("StateTransition", &["trigger"]),
-        F::Relation(RelationFacet::Guard) => ("StateTransition", &["guard"]),
-        F::Relation(RelationFacet::Effect) => ("StateTransition", &["effect"]),
-        F::Relation(RelationFacet::StateActionPhase) => ("StateAction", &["phase"]),
-        _ => return None,
-    };
-    if family != "*" && own.kind != family {
-        return None;
-    }
-    let mut path = own.prefix.clone();
-    path.extend(parts.iter().map(|s| s.to_string()));
-    at(&own.whole, &path).map(|_| path)
-}
-
-pub(super) fn binding(project: &Project, id: Id, facet: &FacetSelector) -> Option<String> {
-    let own = Own::get(project, id)?;
-    path(&own, facet).map(|parts| format!("/{}", parts.join("/")))
-}
-pub(super) fn grouped(facet: &FacetSelector) -> bool {
-    matches!(
-        facet,
-        FacetSelector::Data(DataFacet::Constructor)
-            | FacetSelector::Port(PortFacet::Constructor)
-            | FacetSelector::Occurrence(
-                OccurrenceFacet::Constructor | OccurrenceFacet::MessageKind
-            )
-            | FacetSelector::Event(EventFacet::Constructor)
-    )
-}
-fn pair_json(fact: &FacetReview) -> Value {
-    let json = serde_json::to_value(fact).expect("Typed semantic fact");
-    let (family, value) = json
-        .as_object()
-        .expect("Typed family")
-        .iter()
-        .next()
-        .expect("Family");
-    match family.as_str() {
-        "Member" | "Order" | "Literal" | "Annotation" | "Binding" | "Child" | "Incident" => {
-            value["review"].clone()
-        }
-        "Artifact" => value["review"]
-            .as_object()
-            .expect("Artifact leaf")
-            .values()
-            .next()
-            .expect("Artifact value")
-            .clone(),
-        _ => value
-            .as_object()
-            .expect("Scalar leaf")
-            .values()
-            .next()
-            .expect("Scalar value")
-            .clone(),
-    }
-}
-pub(super) fn observation(fact: &FacetReview, layer: Layer) -> Value {
-    pair_json(fact)[match layer {
-        Layer::Oa => "oa",
-        Layer::Sa => "sa",
-    }]
-    .clone()
-}
-pub(super) fn value(fact: &FacetReview, layer: Layer) -> Option<Value> {
-    observation(fact, layer).get("Value").cloned()
-}
-pub(super) fn source_value(
-    fact: &FacetReview,
-    source: Layer,
-    correspondence: &BTreeMap<Id, Id>,
-) -> Result<Value, String> {
-    // Retain only the source observation before invoking the core's typed UUID
-    // visitor. UUID-shaped prose must never be treated as a reference.
-    let mut json = serde_json::to_value(fact).map_err(|e| e.to_string())?;
-    let leaf = json
-        .as_object_mut()
-        .ok_or("Missing scalar family")?
-        .values_mut()
-        .next()
-        .ok_or("Missing scalar family")?
-        .as_object_mut()
-        .ok_or("Missing scalar leaf")?
-        .values_mut()
-        .next()
-        .ok_or("Missing scalar leaf")?;
-    let selected = observation(fact, source);
-    leaf["oa"] = selected.clone();
-    leaf["sa"] = selected;
-    let typed = serde_json::from_value(json).map_err(|e| e.to_string())?;
-    let mut baseline = SemanticBaseline {
-        facets: vec![typed],
-    };
-    let mut missing = BTreeSet::new();
-    visit_semantic_references(&mut baseline, |id| {
-        if let Some(mapped) = correspondence.get(id) {
-            *id = *mapped;
-        } else {
-            missing.insert(*id);
-        }
-    });
-    if !missing.is_empty() {
-        return Err(format!(
-            "Choose reference counterparts before taking this value: {}",
-            missing
-                .iter()
-                .map(ToString::to_string)
-                .collect::<Vec<_>>()
-                .join(", ")
-        ));
-    }
-    value(&baseline.facets[0], source)
-        .ok_or("Source property is not applicable; review its constructor first.".into())
-}
-pub(super) fn references(fact: &FacetReview) -> BTreeSet<Id> {
-    let mut ids = BTreeSet::new();
-    visit_semantic_references(
-        &mut SemanticBaseline {
-            facets: vec![fact.clone()],
-        },
-        |id| {
-            ids.insert(*id);
-        },
-    );
-    ids
-}

crates/oa-desktop/src/semantic_review/tests.rs

@@ -1,991 +0,0 @@
-use super::*;
-use crate::{app::App, document::Document, workflow::Workflow};
-use serde_json::json;
-
-pub(super) fn send(app: &mut App, event: Event) {
-    let _ = app.update(Message::Workflow(crate::workflow::Event::Semantic(event)));
-}
-pub(super) fn apply(app: &mut App) {
-    let _ = app.update(Message::Workflow(crate::workflow::Event::Apply));
-}
-pub(super) fn state(app: &App) -> &State {
-    let Some(Workflow::Semantic(state)) = &app.workflow else {
-        panic!("Semantic workflow missing: {}", app.status)
-    };
-    state
-}
-fn fixture() -> (Project, Id, Id, Id) {
-    let mut p = Project::empty();
-    let oa = p
-        .add_element(Kind::DataType, Layer::Oa, "Operational range", None)
-        .unwrap();
-    let sa = p
-        .add_element(Kind::DataType, Layer::Sa, "System range", None)
-        .unwrap();
-    for (id, min, max, unit) in [(oa, 0, 20, "m"), (sa, 1, 30, "cm")] {
-        *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::DataType {
-            definition: DataTypeDefinition::Integer {
-                minimum: Some(min),
-                maximum: Some(max),
-            },
-            default: None,
-            unit: unit.into(),
-        };
-    }
-    let trace = add_trace(&mut p, oa, sa, "Range rationale");
-    (p, oa, sa, trace)
-}
-pub(super) fn add_trace(p: &mut Project, oa: Id, sa: Id, name: &str) -> Id {
-    let id = Id::new_v4();
-    p.traces.insert(
-        id,
-        Trace {
-            id,
-            alias: format!("trace_{}", id.simple()),
-            name: name.into(),
-            description: String::new(),
-            oa,
-            sa,
-            kind: TraceKind::Manual,
-            baseline: None,
-        },
-    );
-    id
-}
-pub(super) fn start(app: &mut App, source: Id) {
-    let _ = app.update(Message::StartSemanticReview(source));
-}
-fn facet(value: DataFacet) -> FacetSelector {
-    FacetSelector::Data(value)
-}
-
-#[test]
-fn independent_review_clear_bound_ignores_retained_invalid_other_facet() {
-    let (p, oa, sa, _) = fixture();
-    let mut app = App::with_project(p);
-    let before = app.document.snapshot();
-    start(&mut app, oa);
-    let minimum = "/body/Sa/Shared/DataType/definition/Integer/minimum";
-    let maximum = "/body/Sa/Shared/DataType/definition/Integer/maximum";
-    decide(
-        &mut app,
-        facet(DataFacet::IntegerMinimum),
-        SemanticDecision::Candidate,
-    );
-    send(&mut app, Event::Input(minimum.into(), "-".into()));
-    decide(
-        &mut app,
-        facet(DataFacet::IntegerMinimum),
-        SemanticDecision::KeepTarget,
-    );
-    decide(
-        &mut app,
-        facet(DataFacet::IntegerMaximum),
-        SemanticDecision::Candidate,
-    );
-    assert!(state(&app).can_apply());
-    // Exact event emitted by the upper bound's visible Clear bound button.
-    send(&mut app, Event::Shape(maximum.into(), Value::Null));
-    assert!(state(&app).can_apply(), "{:?}", state(&app).error);
-    assert_eq!(state(&app).draft.as_ref().unwrap().inputs[minimum].raw, "-");
-    assert!(
-        state(&app)
-            .draft
-            .as_ref()
-            .unwrap()
-            .value
-            .pointer(maximum)
-            .unwrap()
-            .is_null()
-    );
-    // Clear must also discard the selected invalid value, without requiring it
-    // to parse before removal. A valid but uncommitted neighboring input survives.
-    send(&mut app, Event::Shape(maximum.into(), json!(30)));
-    send(&mut app, Event::Input(maximum.into(), "29".into()));
-    decide(
-        &mut app,
-        facet(DataFacet::IntegerMinimum),
-        SemanticDecision::Candidate,
-    );
-    assert!(!state(&app).can_apply());
-    send(&mut app, Event::Shape(minimum.into(), Value::Null));
-    assert!(state(&app).can_apply(), "{:?}", state(&app).error);
-    assert_eq!(
-        state(&app).draft.as_ref().unwrap().inputs[maximum].raw,
-        "29"
-    );
-    assert!(
-        !state(&app)
-            .draft
-            .as_ref()
-            .unwrap()
-            .inputs
-            .contains_key(minimum)
-    );
-    assert_eq!(app.document.bundle(), &before.bundle);
-    apply(&mut app);
-    assert!(matches!(
-        app.project().elements[&sa].shared(),
-        Some(SharedBody::DataType {
-            definition: DataTypeDefinition::Integer {
-                minimum: None,
-                maximum: Some(29)
-            },
-            ..
-        })
-    ));
-    let _ = app.update(Message::Undo);
-    assert_eq!(app.document.bundle(), &before.bundle);
-}
-
-#[test]
-fn scoped_literal_list_edits_preserve_unfinished_values_and_other_facet_buffers() {
-    let mut p = Project::empty();
-    let mut pair = vec![];
-    for layer in [Layer::Oa, Layer::Sa] {
-        let item = p
-            .add_element(Kind::ExchangeItem, layer, "Payload", None)
-            .unwrap();
-        let field = p
-            .add_element(Kind::DataField, layer, "Numbers", Some(item))
-            .unwrap();
-        *p.elements.get_mut(&field).unwrap().shared_mut().unwrap() = SharedBody::DataField {
-            type_ref: TypeRef::Integer,
-            minimum: 0,
-            maximum: None,
-            unit: String::new(),
-            direction: ParameterDirection::Unspecified,
-            storage: FieldStorage::Value,
-            default: Some(vec![DataValue::Integer(1), DataValue::Integer(2)]),
-        };
-        pair.push(field);
-    }
-    add_trace(&mut p, pair[0], pair[1], "Numbers review");
-    let mut app = App::with_project(p);
-    start(&mut app, pair[0]);
-    let root = "/body/Sa/Shared/DataField";
-    let minimum = format!("{root}/minimum");
-    let default = format!("{root}/default");
-    let first = format!("{default}/0/Integer");
-    let second = format!("{default}/1/Integer");
-    decide(
-        &mut app,
-        FacetSelector::Field(FieldFacet::Minimum),
-        SemanticDecision::Candidate,
-    );
-    send(&mut app, Event::Input(minimum.clone(), "-".into()));
-    decide(
-        &mut app,
-        FacetSelector::Field(FieldFacet::Minimum),
-        SemanticDecision::KeepTarget,
-    );
-    decide(
-        &mut app,
-        FacetSelector::Field(FieldFacet::Default),
-        SemanticDecision::Candidate,
-    );
-    send(&mut app, Event::Input(first.clone(), "-".into()));
-    send(&mut app, Event::Input(second.clone(), "23".into()));
-    send(
-        &mut app,
-        Event::Append(default.clone(), json!({"Integer": 3})),
-    );
-    assert_eq!(state(&app).draft.as_ref().unwrap().inputs[&first].raw, "-");
-    assert_eq!(
-        state(&app).draft.as_ref().unwrap().inputs[&second].raw,
-        "23"
-    );
-    // Same-variant reselection must not throw away the invalid authored value.
-    send(
-        &mut app,
-        Event::Variant(format!("{default}/0"), json!({"Integer": 0})),
-    );
-    assert_eq!(state(&app).draft.as_ref().unwrap().inputs[&first].raw, "-");
-    send(&mut app, Event::Array(default.clone(), Some(0), 1));
-    assert_eq!(state(&app).draft.as_ref().unwrap().inputs[&first].raw, "23");
-    assert_eq!(state(&app).draft.as_ref().unwrap().inputs[&second].raw, "-");
-    assert!(!state(&app).can_apply());
-    send(&mut app, Event::Array(default, Some(1), 0));
-    assert!(state(&app).can_apply(), "{:?}", state(&app).error);
-    assert_eq!(
-        state(&app).draft.as_ref().unwrap().inputs[&minimum].raw,
-        "-"
-    );
-    apply(&mut app);
-    assert!(
-        matches!(app.project().elements[&pair[1]].shared(), Some(SharedBody::DataField {
-        default: Some(values), minimum: 0, ..
-    }) if values == &vec![DataValue::Integer(23), DataValue::Integer(3)])
-    );
-}
-
-#[test]
-fn independent_review_keyed_fact_titles_keep_live_deleted_and_qualified_identity() {
-    let mut p = Project::empty();
-    let a = Id::new_v4();
-    let b = Id::new_v4();
-    let first = FacetSelector::Child(KeyPair {
-        oa: Some(a),
-        sa: None,
-    });
-    let second = FacetSelector::Child(KeyPair {
-        oa: Some(b),
-        sa: None,
-    });
-    let first_title = super::view::title(&p, &first);
-    let second_title = super::view::title(&p, &second);
-    assert_ne!(first_title, second_title);
-    assert!(first_title.contains(&a.to_string()));
-    assert!(second_title.contains(&b.to_string()));
-    let one = p
-        .add_element(Kind::ExchangeItem, Layer::Oa, "Same name", None)
-        .unwrap();
-    let two = p
-        .add_element(Kind::ExchangeItem, Layer::Oa, "Same name", None)
-        .unwrap();
-    let field = p
-        .add_element(Kind::DataField, Layer::Oa, "Value", Some(one))
-        .unwrap();
-    let annotation = |path| {
-        FacetSelector::Annotation(KeyPair {
-            oa: Some(AnnotationKey { path, field }),
-            sa: None,
-        })
-    };
-    let first_title = super::view::title(&p, &annotation(vec![one, a]));
-    let second_title = super::view::title(&p, &annotation(vec![two, b]));
-    assert_ne!(first_title, second_title);
-    for id in [one, field] {
-        assert!(first_title.contains(&format!("@{}", p.elements[&id].alias)));
-    }
-    assert!(first_title.contains(&a.to_string()));
-    assert!(second_title.contains(&b.to_string()));
-    assert_ne!(super::view::title(&p, &annotation(vec![])), first_title);
-}
-pub(super) fn decide(app: &mut App, selected: FacetSelector, decision: SemanticDecision) {
-    send(app, Event::Select(selected.clone()));
-    send(app, Event::Decide(selected, Some(decision)));
-}
-
-#[test]
-fn scalar_keep_take_candidate_commit_exact_source_and_history_in_both_directions() {
-    for reverse in [false, true] {
-        let (p, oa, sa, trace) = fixture();
-        let mut app = App::with_project(p);
-        let mut bundle = app.document.bundle().clone();
-        bundle
-            .files
-            .get_mut(&bundle.entry)
-            .unwrap()
-            .insert_str(0, "// Retain this engineering rationale.\r\n");
-        app.document.apply_bundle(bundle).unwrap();
-        let before = app.document.snapshot();
-        let revision = app.document.revision();
-        let (source, target, prefix, expected_max, kept_min) = if reverse {
-            (sa, oa, "/body/Oa/Shared/DataType", 30, 0)
-        } else {
-            (oa, sa, "/body/Sa/Shared/DataType", 20, 1)
-        };
-        start(&mut app, source);
-        decide(
-            &mut app,
-            facet(DataFacet::IntegerMinimum),
-            SemanticDecision::KeepTarget,
-        );
-        decide(
-            &mut app,
-            facet(DataFacet::IntegerMaximum),
-            SemanticDecision::TakeSource,
-        );
-        decide(
-            &mut app,
-            facet(DataFacet::Unit),
-            SemanticDecision::Candidate,
-        );
-        send(
-            &mut app,
-            Event::Input(format!("{prefix}/unit"), "kg\n  exact suffix ".into()),
-        );
-        let prepared =
-            prepare_semantic_transition(app.project(), state(&app).plan.as_ref().unwrap())
-                .unwrap()
-                .project;
-        assert!(state(&app).can_apply(), "{:?}", state(&app).error);
-        assert_eq!(
-            app.project(),
-            &before.decoded.project,
-            "Preview must not mutate accepted state"
-        );
-        apply(&mut app);
-        assert!(app.workflow.is_none(), "{}", app.status);
-        assert_eq!(
-            app.project(),
-            &prepared,
-            "Apply must equal the exact reviewed project including diagrams"
-        );
-        assert_eq!(app.document.revision(), revision + 1);
-        let Some(SharedBody::DataType {
-            definition: DataTypeDefinition::Integer { minimum, maximum },
-            unit,
-            ..
-        }) = app.project().elements[&target].shared()
-        else {
-            panic!()
-        };
-        assert_eq!((*minimum, *maximum), (Some(kept_min), Some(expected_max)));
-        assert_eq!(unit, "kg\n  exact suffix ");
-        let baseline = app.project().traces[&trace]
-            .baseline
-            .as_ref()
-            .unwrap()
-            .semantic
-            .as_ref()
-            .unwrap();
-        assert_eq!(baseline.facets.len(), 3, "Unselected facts stay unreviewed");
-        assert!(
-            app.document.bundle().files[&app.document.bundle().entry]
-                .contains("// Retain this engineering rationale.")
-        );
-        let accepted = app.document.snapshot();
-        let _ = app.update(Message::Undo);
-        assert_eq!(app.document.bundle(), &before.bundle);
-        assert_eq!(app.project(), &before.decoded.project);
-        let _ = app.update(Message::Redo);
-        assert_eq!(app.document.bundle(), &accepted.bundle);
-        assert_eq!(app.project(), &accepted.decoded.project);
-    }
-}
-
-#[test]
-fn invalid_numeric_draft_and_protected_edits_retain_workflow_and_source() {
-    let (p, oa, _, _) = fixture();
-    let mut app = App::with_project(p);
-    let before = app.document.snapshot();
-    start(&mut app, oa);
-    decide(
-        &mut app,
-        facet(DataFacet::IntegerMinimum),
-        SemanticDecision::Candidate,
-    );
-    let path = "/body/Sa/Shared/DataType/definition/Integer/minimum";
-    send(&mut app, Event::Input(path.into(), "-".into()));
-    assert!(!state(&app).can_apply());
-    send(&mut app, Event::Tab(Tab::References));
-    assert!(
-        state(&app).error.is_some(),
-        "Navigation must retain visible validation errors"
-    );
-    apply(&mut app);
-    assert_eq!(state(&app).draft.as_ref().unwrap().inputs[path].raw, "-");
-    assert_eq!(app.document.bundle(), &before.bundle);
-    send(&mut app, Event::Input(path.into(), "2".into()));
-    send(&mut app, Event::Input("/alias".into(), "unexpected".into()));
-    assert!(!state(&app).can_apply());
-    assert!(
-        state(&app)
-            .error
-            .as_ref()
-            .unwrap()
-            .contains("selected review")
-    );
-    assert_eq!(app.project(), &before.decoded.project);
-    send(&mut app, Event::Preview);
-    assert!(state(&app).can_apply());
-}
-
-#[test]
-fn explicit_trace_selection_updates_only_that_history() {
-    let (mut p, oa, sa, first) = fixture();
-    let second = add_trace(&mut p, oa, sa, "Independent assessment");
-    p.traces.get_mut(&second).unwrap().kind = TraceKind::Item;
-    let mut app = App::with_project(p);
-    start(&mut app, oa);
-    assert!(state(&app).trace.is_none());
-    assert!(!state(&app).can_apply());
-    send(
-        &mut app,
-        Event::Trace(Choice {
-            id: second,
-            label: "Independent assessment".into(),
-        }),
-    );
-    decide(
-        &mut app,
-        facet(DataFacet::Unit),
-        SemanticDecision::KeepTarget,
-    );
-    apply(&mut app);
-    assert!(app.workflow.is_none(), "{}", app.status);
-    assert!(
-        app.project().traces[&first]
-            .baseline
-            .as_ref()
-            .and_then(|b| b.semantic.as_ref())
-            .is_none()
-    );
-    assert!(
-        app.project().traces[&second]
-            .baseline
-            .as_ref()
-            .unwrap()
-            .semantic
-            .is_some()
-    );
-}
-
-#[test]
-fn stale_plan_and_source_writeback_failure_do_not_lose_decisions_or_history() {
-    let (p, oa, _, _) = fixture();
-    let mut app = App::with_project(p);
-    start(&mut app, oa);
-    decide(
-        &mut app,
-        facet(DataFacet::Unit),
-        SemanticDecision::KeepTarget,
-    );
-    app.document
-        .execute(Command::Rename(oa, "Changed outside preview".into()))
-        .unwrap();
-    let before = app.document.snapshot();
-    let revision = app.document.revision();
-    apply(&mut app);
-    assert!(state(&app).error.as_ref().unwrap().contains("stale"));
-    assert_eq!(state(&app).decisions.len(), 1);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert_eq!(app.document.revision(), revision);
-
-    let (p, oa, _, _) = fixture();
-    let mut app = App::with_project(p);
-    let bundle = app.document.bundle().clone();
-    let mut limits = source_project::ProjectLimits::default();
-    limits.model.max_source_bytes = bundle.files.values().map(String::len).sum::<usize>() + 10;
-    app.document = Document::from_bundle(bundle, limits).unwrap();
-    let before = app.document.snapshot();
-    start(&mut app, oa);
-    decide(
-        &mut app,
-        facet(DataFacet::Unit),
-        SemanticDecision::Candidate,
-    );
-    send(
-        &mut app,
-        Event::Input(
-            "/body/Sa/Shared/DataType/unit".into(),
-            "long final unit ".repeat(40),
-        ),
-    );
-    assert!(state(&app).can_apply());
-    apply(&mut app);
-    assert!(state(&app).error.is_some());
-    assert_eq!(state(&app).decisions.len(), 1);
-    assert_eq!(app.document.bundle(), &before.bundle);
-    assert_eq!(app.document.revision(), 0);
-    assert!(!app.document.can_undo());
-}
-
-#[test]
-fn candidate_mixed_with_reference_take_uses_typed_correspondence_not_text_guessing() {
-    let (mut p, oa, sa, _) = fixture();
-    let parent_oa = p
-        .add_element(Kind::DataType, Layer::Oa, "OA parent", None)
-        .unwrap();
-    let parent_sa = p
-        .add_element(Kind::DataType, Layer::Sa, "SA parent", None)
-        .unwrap();
-    for id in [parent_oa, parent_sa] {
-        *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::DataType {
-            definition: DataTypeDefinition::Record { supertype: None },
-            default: None,
-            unit: String::new(),
-        };
-    }
-    // ExchangeItem supertypes are an independent optional typed reference.
-    for (id, parent) in [(oa, Some(parent_oa)), (sa, None)] {
-        *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::DataType {
-            definition: DataTypeDefinition::Record { supertype: parent },
-            default: None,
-            unit: String::new(),
-        };
-    }
-    let mut app = App::with_project(p);
-    start(&mut app, oa);
-    decide(
-        &mut app,
-        facet(DataFacet::RecordSupertype),
-        SemanticDecision::TakeSource,
-    );
-    assert!(!state(&app).can_apply());
-    send(
-        &mut app,
-        Event::ReferenceOa(Choice {
-            id: parent_oa,
-            label: "OA parent".into(),
-        }),
-    );
-    send(
-        &mut app,
-        Event::ReferenceSa(Choice {
-            id: parent_sa,
-            label: "SA parent".into(),
-        }),
-    );
-    send(&mut app, Event::AddReference);
-    decide(
-        &mut app,
-        facet(DataFacet::Unit),
-        SemanticDecision::Candidate,
-    );
-    send(
-        &mut app,
-        Event::Input(
-            "/body/Sa/Shared/DataType/unit".into(),
-            parent_oa.to_string(),
-        ),
-    );
-    assert!(state(&app).can_apply(), "{:?}", state(&app).error);
-    apply(&mut app);
-    let Some(SharedBody::DataType {
-        definition: DataTypeDefinition::Record { supertype },
-        unit,
-        ..
-    }) = app.project().elements[&sa].shared()
-    else {
-        panic!()
-    };
-    assert_eq!(*supertype, Some(parent_sa));
-    assert_eq!(
-        unit,
-        &parent_oa.to_string(),
-        "UUID-shaped prose must not be remapped"
-    );
-}
-
-#[test]
-fn read_only_structured_facts_and_partial_rollup_are_honest() {
-    let (p, oa, _, trace) = fixture();
-    let mut app = App::with_project(p);
-    start(&mut app, oa);
-    send(
-        &mut app,
-        Event::Decide(
-            FacetSelector::Literal(KeyPair {
-                oa: Some("Unpaired".into()),
-                sa: None,
-            }),
-            Some(SemanticDecision::TakeSource),
-        ),
-    );
-    assert!(state(&app).decisions.is_empty());
-    assert!(state(&app).error.is_some());
-    decide(
-        &mut app,
-        facet(DataFacet::Unit),
-        SemanticDecision::KeepTarget,
-    );
-    apply(&mut app);
-    let rollup = trace_semantic_drift(
-        app.project(),
-        &app.project().traces[&trace],
-        &BTreeMap::new(),
-    )
-    .unwrap();
-    assert!(rollup.own_unreviewed);
-    assert!(summary(app.project(), &app.project().traces[&trace]).contains("Unreviewed"));
-    let mut request = State::new(app.project(), trace).unwrap();
-    request.update(
-        app.project(),
-        Event::Select(facet(DataFacet::IntegerMaximum)),
-    );
-    let _ = request.view(app.project());
-    assert_eq!(
-        scalar::value(
-            &capture_facet(
-                app.project(),
-                oa,
-                request.target(app.project()).unwrap(),
-                &facet(DataFacet::Default)
-            )
-            .unwrap(),
-            Layer::Oa
-        ),
-        Some(json!(null))
-    );
-}
-
-#[test]
-fn first_equal_constructor_acknowledges_only_kind_and_allows_independent_leaves() {
-    let (p, oa, _, trace) = fixture();
-    let mut app = App::with_project(p);
-    start(&mut app, oa);
-    assert!(state(&app).can_acknowledge_constructor(app.project(), &facet(DataFacet::Constructor)));
-    decide(
-        &mut app,
-        facet(DataFacet::Constructor),
-        SemanticDecision::KeepTarget,
-    );
-    decide(
-        &mut app,
-        facet(DataFacet::Unit),
-        SemanticDecision::Candidate,
-    );
-    send(
-        &mut app,
-        Event::Input("/body/Sa/Shared/DataType/unit".into(), "local unit".into()),
-    );
-    assert!(
-        state(&app).can_apply(),
-        "{:?}",
-        state(&app).plan.as_ref().map(|p| &p.conflicts)
-    );
-    apply(&mut app);
-    let facts = &app.project().traces[&trace]
-        .baseline
-        .as_ref()
-        .unwrap()
-        .semantic
-        .as_ref()
-        .unwrap()
-        .facets;
-    assert_eq!(facts.len(), 2);
-    assert!(
-        facts
-            .iter()
-            .any(|f| f.selector() == facet(DataFacet::Constructor))
-    );
-    assert!(
-        !facts
-            .iter()
-            .any(|f| f.selector() == facet(DataFacet::IntegerMinimum))
-    );
-    start(&mut app, oa);
-    assert!(
-        !state(&app).can_acknowledge_constructor(app.project(), &facet(DataFacet::Constructor))
-    );
-    let remaining: Vec<_> = state(&app)
-        .facts
-        .iter()
-        .filter(|f| f.drift == Drift::Unreviewed)
-        .map(|f| f.selector.clone())
-        .collect();
-    for selector in remaining {
-        decide(&mut app, selector, SemanticDecision::KeepTarget);
-    }
-    apply(&mut app);
-    assert!(app.workflow.is_none(), "{}", app.status);
-    assert!(
-        !trace_semantic_drift(
-            app.project(),
-            &app.project().traces[&trace],
-            &BTreeMap::new()
-        )
-        .unwrap()
-        .own_unreviewed
-    );
-}
-
-#[test]
-fn state_kind_scalar_uses_typed_candidate_and_core_validation() {
-    let mut p = Project::empty();
-    let mut pair = vec![];
-    for layer in [Layer::Oa, Layer::Sa] {
-        let machine = p
-            .add_element(Kind::StateMachine, layer, "Machine", None)
-            .unwrap();
-        let region = p
-            .add_element(Kind::Region, layer, "Region", Some(machine))
-            .unwrap();
-        pair.push(
-            p.add_element(Kind::State, layer, "Ready", Some(region))
-                .unwrap(),
-        );
-    }
-    add_trace(&mut p, pair[0], pair[1], "State review");
-    let mut app = App::with_project(p);
-    start(&mut app, pair[0]);
-    decide(
-        &mut app,
-        FacetSelector::State(StateFacet::Kind),
-        SemanticDecision::Candidate,
-    );
-    send(
-        &mut app,
-        Event::Shape("/body/Sa/Shared/State/kind".into(), json!("Final")),
-    );
-    assert!(
-        state(&app).can_apply(),
-        "{:?}",
-        state(&app).plan.as_ref().map(|p| &p.conflicts)
-    );
-    let expected = state(&app).proposed.clone().unwrap();
-    apply(&mut app);
-    assert_eq!(app.project(), &expected);
-    assert_eq!(app.project().elements[&pair[1]].kind(), Kind::Final);
-}
-
-#[test]
-fn relation_candidates_preserve_endpoints_and_combine_selected_roles_and_bounds() {
-    let mut p = Project::empty();
-    let mut pair = vec![];
-    for layer in [Layer::Oa, Layer::Sa] {
-        let a = p
-            .add_element(Kind::DataType, layer, "Origin type", None)
-            .unwrap();
-        let b = p
-            .add_element(Kind::DataType, layer, "Destination type", None)
-            .unwrap();
-        for id in [a, b] {
-            *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::DataType {
-                definition: DataTypeDefinition::Record { supertype: None },
-                default: None,
-                unit: String::new(),
-            };
-        }
-        let relation = p.relate(RelationKind::DataAssociation, "Association", a, b);
-        if let RelationBody::DataAssociation { source_role, .. } =
-            &mut p.relations.get_mut(&relation).unwrap().body
-        {
-            *source_role = if layer == Layer::Oa {
-                "Authored source role"
-            } else {
-                "Local role"
-            }
-            .into();
-        }
-        pair.push(relation);
-    }
-    add_trace(&mut p, pair[0], pair[1], "Association review");
-    let original = p.relations[&pair[1]].clone();
-    let mut app = App::with_project(p);
-    start(&mut app, pair[0]);
-    decide(
-        &mut app,
-        FacetSelector::Relation(RelationFacet::SourceRole),
-        SemanticDecision::TakeSource,
-    );
-    decide(
-        &mut app,
-        FacetSelector::Relation(RelationFacet::TargetMaximum),
-        SemanticDecision::Candidate,
-    );
-    send(
-        &mut app,
-        Event::Shape("/body/DataAssociation/target_maximum".into(), json!(4)),
-    );
-    assert!(state(&app).can_apply(), "{:?}", state(&app).error);
-    apply(&mut app);
-    let accepted = &app.project().relations[&pair[1]];
-    assert_eq!(accepted.alias, original.alias);
-    assert_eq!(
-        (accepted.source(), accepted.target()),
-        (original.source(), original.target())
-    );
-    let RelationBody::DataAssociation {
-        source_role,
-        target_maximum,
-        ..
-    } = &accepted.body
-    else {
-        panic!()
-    };
-    assert_eq!(source_role, "Authored source role");
-    assert_eq!(*target_maximum, Some(4));
-}
-
-#[test]
-fn deselected_invalid_candidate_is_retained_but_does_not_poison_another_selected_scalar() {
-    let (p, oa, sa, _) = fixture();
-    let mut app = App::with_project(p);
-    start(&mut app, oa);
-    let path = "/body/Sa/Shared/DataType/definition/Integer/minimum";
-    decide(
-        &mut app,
-        facet(DataFacet::IntegerMinimum),
-        SemanticDecision::Candidate,
-    );
-    send(&mut app, Event::Input(path.into(), "-".into()));
-    decide(
-        &mut app,
-        facet(DataFacet::IntegerMinimum),
-        SemanticDecision::KeepTarget,
-    );
-    decide(
-        &mut app,
-        facet(DataFacet::Unit),
-        SemanticDecision::Candidate,
-    );
-    send(
-        &mut app,
-        Event::Input(
-            "/body/Sa/Shared/DataType/unit".into(),
-            "reviewed local".into(),
-        ),
-    );
-    assert_eq!(state(&app).draft.as_ref().unwrap().inputs[path].raw, "-");
-    assert!(state(&app).can_apply(), "{:?}", state(&app).error);
-    apply(&mut app);
-    let Some(SharedBody::DataType {
-        definition: DataTypeDefinition::Integer { minimum, .. },
-        unit,
-        ..
-    }) = app.project().elements[&sa].shared()
-    else {
-        panic!()
-    };
-    assert_eq!(*minimum, Some(1));
-    assert_eq!(unit, "reviewed local");
-}
-
-#[test]
-fn inherited_annotation_impact_requires_exact_acceptance_and_edits_clear_approval() {
-    let mut p = Project::empty();
-    let oa = p
-        .add_element(Kind::DataType, Layer::Oa, "Operational record", None)
-        .unwrap();
-    let sa = p
-        .add_element(Kind::DataType, Layer::Sa, "System record", None)
-        .unwrap();
-    let base = p
-        .add_element(Kind::DataType, Layer::Sa, "Inherited record", None)
-        .unwrap();
-    for (id, supertype) in [(oa, None), (sa, Some(base)), (base, None)] {
-        *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::DataType {
-            definition: DataTypeDefinition::Record { supertype },
-            default: None,
-            unit: String::new(),
-        };
-    }
-    let leaf = p
-        .add_element(Kind::DataField, Layer::Sa, "Inherited value", Some(base))
-        .unwrap();
-    let item = p
-        .add_element(Kind::ExchangeItem, Layer::Sa, "Telemetry", None)
-        .unwrap();
-    let root = p
-        .add_element(Kind::DataField, Layer::Sa, "Position", Some(item))
-        .unwrap();
-    for (id, type_ref) in [(leaf, TypeRef::Real), (root, TypeRef::Named(sa))] {
-        *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::DataField {
-            type_ref,
-            minimum: 0,
-            maximum: Some(1),
-            unit: String::new(),
-            direction: ParameterDirection::Unspecified,
-            storage: FieldStorage::Value,
-            default: None,
-        };
-    }
-    let a = p
-        .add_element(Kind::Function, Layer::Sa, "Send", None)
-        .unwrap();
-    let b = p
-        .add_element(Kind::Function, Layer::Sa, "Receive", None)
-        .unwrap();
-    let exchange = p.relate(RelationKind::FunctionalExchange, "Telemetry exchange", a, b);
-    let (source_port, target_port) = match &mut p.relations.get_mut(&exchange).unwrap().body {
-        RelationBody::FunctionalExchange {
-            source_port,
-            target_port,
-            items,
-            ..
-        } => {
-            items.push(item);
-            (*source_port, *target_port)
-        }
-        _ => panic!(),
-    };
-    for id in [source_port, target_port] {
-        match p.elements.get_mut(&id).unwrap().shared_mut().unwrap() {
-            SharedBody::Port {
-                contract: PortContract::FunctionInput { incoming_items },
-                ..
-            } => incoming_items.push(item),
-            SharedBody::Port {
-                contract: PortContract::FunctionOutput { outgoing_items },
-                ..
-            } => outgoing_items.push(item),
-            _ => panic!(),
-        }
-    }
-    let scenario = p
-        .add_element(Kind::Scenario, Layer::Sa, "Telemetry scenario", None)
-        .unwrap();
-    let message = p
-        .add_element(Kind::Occurrence, Layer::Sa, "Send position", Some(scenario))
-        .unwrap();
-    *p.elements.get_mut(&message).unwrap().shared_mut().unwrap() = SharedBody::Occurrence {
-        body: OccurrenceBody::Exchange {
-            exchange: Some(exchange),
-            sender: None,
-            receiver: None,
-            message_kind: MessageKind::Asynchronous,
-            reply_to: None,
-            values: vec![MessageValue {
-                path: vec![root],
-                field: leaf,
-                expression: "current position".into(),
-            }],
-        },
-        precondition: String::new(),
-        postcondition: String::new(),
-    };
-    p.elements
-        .get_mut(&scenario)
-        .unwrap()
-        .steps_mut()
-        .unwrap()
-        .push(message);
-    add_trace(&mut p, oa, sa, "Record inheritance review");
-    let mut app = App::with_project(p);
-    let before = app.document.snapshot();
-    start(&mut app, oa);
-    decide(
-        &mut app,
-        facet(DataFacet::RecordSupertype),
-        SemanticDecision::TakeSource,
-    );
-    assert!(!state(&app).can_apply());
-    let impacts = &state(&app).plan.as_ref().unwrap().impacts;
-    assert_eq!(impacts.len(), 1);
-    assert_eq!(impacts[0].object, message);
-    let exact = impacts[0].clone();
-    send(&mut app, Event::AcceptImpact(0, true));
-    assert!(
-        state(&app).can_apply(),
-        "{:?}",
-        state(&app).plan.as_ref().map(|p| &p.conflicts)
-    );
-    assert_eq!(
-        state(&app).plan.as_ref().unwrap().request.accepted_impacts,
-        vec![exact]
-    );
-    decide(
-        &mut app,
-        facet(DataFacet::Unit),
-        SemanticDecision::KeepTarget,
-    );
-    assert!(
-        state(&app)
-            .plan
-            .as_ref()
-            .unwrap()
-            .request
-            .accepted_impacts
-            .is_empty()
-    );
-    assert!(!state(&app).can_apply());
-    send(&mut app, Event::AcceptImpact(0, true));
-    let expected = state(&app).proposed.clone().unwrap();
-    assert_eq!(app.document.bundle(), &before.bundle);
-    apply(&mut app);
-    assert_eq!(app.project(), &expected);
-    let Some(SharedBody::Occurrence {
-        body: OccurrenceBody::Exchange { values, .. },
-        ..
-    }) = app.project().elements[&message].shared()
-    else {
-        panic!()
-    };
-    assert!(values.is_empty());
-    let _ = app.update(Message::Undo);
-    assert_eq!(app.document.bundle(), &before.bundle);
-}

crates/oa-desktop/src/semantic_review/view.rs

@@ -1,886 +0,0 @@
-use super::*;
-use crate::{style, views::short};
-use iced::{
-    Element, Fill,
-    widget::{
-        Space, button, checkbox, column, container, pick_list, row, scrollable, text, text_input,
-    },
-};
-
-fn event(event: Event) -> Message {
-    Message::Workflow(crate::workflow::Event::Semantic(event))
-}
-fn action<'a>(label: impl Into<String>, event_value: Event) -> iced::widget::Button<'a, Message> {
-    button(text(label.into()).size(12))
-        .padding([7, 9])
-        .style(style::nav)
-        .on_press(event(event_value))
-}
-pub(super) fn choice(project: &Project, id: Id) -> Choice {
-    let alias = project
-        .elements
-        .get(&id)
-        .map(|v| v.alias.as_str())
-        .or_else(|| project.relations.get(&id).map(|v| v.alias.as_str()))
-        .or_else(|| project.artifact_links.get(&id).map(|v| v.alias.as_str()));
-    Choice {
-        id,
-        label: alias.map_or_else(
-            || format!("Deleted reference · {id}"),
-            |alias| format!("{} · @{alias}", project.named(id)),
-        ),
-    }
-}
-fn words(value: &str) -> String {
-    let mut out = String::new();
-    for (index, c) in value.chars().enumerate() {
-        if c == '_' {
-            out.push(' ');
-        } else {
-            if index > 0 && c.is_uppercase() {
-                out.push(' ');
-            }
-            out.push(c);
-        }
-    }
-    out
-}
-pub(super) fn group(facet: &FacetSelector) -> &'static str {
-    match facet {
-        FacetSelector::Header(_) => "Name and ownership",
-        FacetSelector::Data(_) | FacetSelector::Field(_) | FacetSelector::Literal(_) => {
-            "Data and defaults"
-        }
-        FacetSelector::Port(_) | FacetSelector::Interface(_) | FacetSelector::ExchangeItem(_) => {
-            "Contracts and interfaces"
-        }
-        FacetSelector::Scenario(_)
-        | FacetSelector::Lifeline(_)
-        | FacetSelector::Occurrence(_)
-        | FacetSelector::Event(_)
-        | FacetSelector::State(_)
-        | FacetSelector::Annotation(_)
-        | FacetSelector::Binding(_) => "Behavior and scenarios",
-        FacetSelector::Relation(_) | FacetSelector::Constraint(_) => {
-            "Relationships and constraints"
-        }
-        FacetSelector::Member { .. } | FacetSelector::Order(_) => "Membership and order",
-        FacetSelector::Child(_)
-        | FacetSelector::Incident { .. }
-        | FacetSelector::Artifact { .. } => "Attached records",
-    }
-}
-pub(super) fn title(project: &Project, facet: &FacetSelector) -> String {
-    let keys = |keys: &KeyPair<Id>, missing: &str| {
-        format!(
-            "{} ↔ {}",
-            keys.oa
-                .map(|id| choice(project, id).label)
-                .unwrap_or_else(|| missing.into()),
-            keys.sa
-                .map(|id| choice(project, id).label)
-                .unwrap_or_else(|| missing.into())
-        )
-    };
-    match facet {
-        FacetSelector::Member {
-            collection,
-            keys: pair,
-        } => format!(
-            "{} · {}",
-            words(&format!("{collection:?}")),
-            keys(pair, "No identity")
-        ),
-        FacetSelector::Order(collection) => format!("{} order", words(&format!("{collection:?}"))),
-        FacetSelector::Literal(pair) => format!(
-            "Literal · {} ↔ {}",
-            pair.oa
-                .as_ref()
-                .map(|s| format!("{s:?}"))
-                .unwrap_or_else(|| "No identity".into()),
-            pair.sa
-                .as_ref()
-                .map(|s| format!("{s:?}"))
-                .unwrap_or_else(|| "No identity".into())
-        ),
-        FacetSelector::Annotation(pair) => format!(
-            "Message value · {} ↔ {}",
-            pair.oa
-                .as_ref()
-                .map(|key| annotation_title(project, key))
-                .unwrap_or_else(|| "Absent".into()),
-            pair.sa
-                .as_ref()
-                .map(|key| annotation_title(project, key))
-                .unwrap_or_else(|| "Absent".into())
-        ),
-        FacetSelector::Binding(pair) => format!("Lifeline binding · {}", keys(pair, "Absent")),
-        FacetSelector::Child(pair) => format!("Owned child · {}", keys(pair, "Absent")),
-        FacetSelector::Incident { keys: pair, end } => {
-            format!("Incident {end:?} · {}", keys(pair, "Absent"))
-        }
-        FacetSelector::Artifact { keys: pair, facet } => {
-            format!(
-                "Artifact {} · {}",
-                words(&format!("{facet:?}")),
-                keys(pair, "Absent")
-            )
-        }
-        _ => {
-            let json = serde_json::to_value(facet).expect("Typed selector");
-            let value = json
-                .as_object()
-                .expect("Family")
-                .values()
-                .next()
-                .expect("Leaf");
-            words(value.as_str().unwrap_or("Property"))
-        }
-    }
-}
-fn annotation_title(project: &Project, key: &AnnotationKey) -> String {
-    key.path
-        .iter()
-        .chain(std::iter::once(&key.field))
-        .map(|id| choice(project, *id).label)
-        .collect::<Vec<_>>()
-        .join(" / ")
-}
-fn drift(drift: Drift) -> &'static str {
-    match drift {
-        Drift::Unreviewed => "Unreviewed",
-        Drift::Unchanged => "Unchanged since review",
-        Drift::OaChanged => "Operational changed",
-        Drift::SaChanged => "System changed",
-        Drift::BothChanged => "Both changed",
-    }
-}
-pub(crate) fn summary(project: &Project, trace: &Trace) -> String {
-    let references = BTreeMap::from([(trace.oa, trace.sa)]);
-    match trace_semantic_drift(project, trace, &references) {
-        Ok(value) => format!(
-            "Semantics: {}{} · Linked: {}{}",
-            drift(value.own),
-            if value.own_unreviewed && value.own != Drift::Unreviewed {
-                " · incomplete review"
-            } else {
-                ""
-            },
-            drift(value.linked),
-            if value.linked_unreviewed && value.linked != Drift::Unreviewed {
-                " · incomplete review"
-            } else {
-                ""
-            }
-        ),
-        Err(error) => format!("Semantic review unavailable: {error}"),
-    }
-}
-fn formatted(project: &Project, value: &Value, references: &BTreeSet<Id>) -> String {
-    match value {
-        Value::Null => "Not set".into(),
-        Value::Bool(value) => if *value { "Yes" } else { "No" }.into(),
-        Value::Number(value) => value.to_string(),
-        Value::String(value) => {
-            if let Ok(id) = value.parse::<Id>()
-                && references.contains(&id)
-            {
-                choice(project, id).label
-            } else if value.is_empty() {
-                "Empty text".into()
-            } else {
-                format!("“{value}”")
-            }
-        }
-        Value::Array(values) if values.is_empty() => "Empty list (0 members)".into(),
-        Value::Array(values) => values
-            .iter()
-            .enumerate()
-            .map(|(i, v)| format!("{}. {}", i + 1, formatted(project, v, references)))
-            .collect::<Vec<_>>()
-            .join("\n"),
-        Value::Object(values) => values
-            .iter()
-            .map(|(key, value)| {
-                format!("{}: {}", words(key), formatted(project, value, references))
-            })
-            .collect::<Vec<_>>()
-            .join("\n"),
-    }
-}
-fn observed(project: &Project, fact: Option<&FacetReview>, layer: Layer) -> String {
-    let Some(fact) = fact else {
-        return "Unreviewed — no previous observation".into();
-    };
-    let value = scalar::observation(fact, layer);
-    if value.as_str() == Some("NotApplicable") {
-        "Not applicable".into()
-    } else if keyed::supported(&fact.selector()) {
-        if value["Value"].as_bool() == Some(true) {
-            "Present".into()
-        } else {
-            "Absent".into()
-        }
-    } else {
-        formatted(project, &value["Value"], &scalar::references(fact))
-    }
-}
-
-impl State {
-    pub fn view<'a>(&'a self, project: &'a Project) -> Element<'a, Message> {
-        let trace = self.trace.and_then(|id| project.traces.get(&id));
-        let mut traces: Vec<_> = project
-            .traces
-            .values()
-            .filter(|t| t.oa == self.anchor || t.sa == self.anchor)
-            .map(|t| Choice {
-                id: t.id,
-                label: format!(
-                    "{} · {:?} · {} ↔ {} · @{}",
-                    t.name,
-                    t.kind,
-                    project.named(t.oa),
-                    project.named(t.sa),
-                    t.alias
-                ),
-            })
-            .collect();
-        traces.sort_by(|a, b| a.label.cmp(&b.label));
-        let selected_trace = traces.iter().find(|c| Some(c.id) == self.trace).cloned();
-        let direction = if self.direction == TransitionDirection::OaToSa {
-            "Use Operational changes in System"
-        } else {
-            "Use System changes in Operational"
-        };
-        let mut content = column![
-            text("Review semantics").size(22),
-            row![
-                pick_list(traces, selected_trace, |c| event(Event::Trace(c))).placeholder("Choose a trace / review history").text_size(12).padding(7).width(Fill),
-                action(direction, Event::Direction(if self.direction == TransitionDirection::OaToSa { TransitionDirection::SaToOa } else { TransitionDirection::OaToSa })),
-            ].spacing(8),
-            text("Changing trace or direction starts a new review draft. Other pending edits remain separate.").size(10).color(style::MUTED),
-            row![action("Properties", Event::Tab(Tab::Facts)), action("Members / literals", Event::Tab(Tab::Members)), action(format!("History ({})", self.resets.len()), Event::Tab(Tab::History)), action(format!("Reference pairs ({})", self.references.len()), Event::Tab(Tab::References)), action(format!("Additional changes ({})", self.plan.as_ref().map_or(0, |p| p.impacts.len())), Event::Tab(Tab::Impacts)), Space::new().width(Fill), action("Refresh preview", Event::Preview)].spacing(6).wrap(),
-        ].spacing(8);
-        let body = match self.tab {
-            Tab::Facts => self.facts_view(project),
-            Tab::References => self.references_view(project),
-            Tab::Members => self.members_view(project),
-            Tab::History => self.history_view(project),
-            Tab::Impacts => self.impacts_view(project),
-        };
-        content = content.push(body);
-        if let Some(error) = &self.error {
-            content = content.push(
-                text(error)
-                    .size(12)
-                    .color(iced::Color::from_rgb8(178, 54, 58)),
-            );
-        }
-        if let Some(plan) = &self.plan {
-            for error in &plan.conflicts {
-                content = content.push(
-                    text(error)
-                        .size(12)
-                        .color(iced::Color::from_rgb8(178, 54, 58)),
-                );
-            }
-        }
-        let unreviewed = self
-            .facts
-            .iter()
-            .filter(|f| f.drift == Drift::Unreviewed)
-            .count();
-        content = content.push(text(format!("{} decisions · {} exact resets · {unreviewed} unreviewed facts · Ordered, annotation, binding and attached-record decisions remain pending.", self.decisions.len(), self.resets.len())).size(10).color(style::MUTED));
-        if let Some(trace) = trace {
-            content = content.push(text(summary(project, trace)).size(10).color(style::MUTED));
-        }
-        content
-            .push(
-                row![
-                    text(
-                        "Apply updates the selected history and model together; Undo restores both."
-                    )
-                    .size(10)
-                    .width(Fill),
-                    button(text("Cancel").size(12))
-                        .padding(8)
-                        .style(style::nav)
-                        .on_press(Message::Workflow(crate::workflow::Event::Cancel)),
-                    button(text("Apply reviewed changes").size(12))
-                        .padding(8)
-                        .on_press_maybe(
-                            self.can_apply()
-                                .then_some(Message::Workflow(crate::workflow::Event::Apply))
-                        ),
-                ]
-                .spacing(8)
-                .align_y(iced::Center),
-            )
-            .into()
-    }
-
-    fn facts_view<'a>(&'a self, project: &'a Project) -> Element<'a, Message> {
-        let mut list = column![
-            checkbox(self.show_unchanged)
-                .label("Include unchanged facts")
-                .text_size(11)
-                .on_toggle(|v| event(Event::ShowUnchanged(v)))
-        ]
-        .spacing(5);
-        let mut groups: BTreeMap<&str, Vec<&FacetDrift>> = BTreeMap::new();
-        for fact in &self.facts {
-            if self.show_unchanged
-                || fact.drift != Drift::Unchanged
-                || self.decisions.contains_key(&fact.selector)
-                || self.selected.as_ref() == Some(&fact.selector)
-            {
-                groups.entry(group(&fact.selector)).or_default().push(fact);
-            }
-        }
-        for (group, facts) in groups {
-            list = list.push(text(group).size(12).color(style::TEAL));
-            for fact in facts {
-                let mark = match self.decisions.get(&fact.selector) {
-                    Some(SemanticDecision::KeepTarget) => "Keep · ",
-                    Some(SemanticDecision::TakeSource) => "Take · ",
-                    Some(SemanticDecision::Candidate) => "Final value · ",
-                    None => "",
-                };
-                list = list.push(
-                    button(
-                        column![
-                            text(short(&title(project, &fact.selector), 52)).size(12),
-                            text(format!("{mark}{}", drift(fact.drift))).size(10)
-                        ]
-                        .spacing(3),
-                    )
-                    .padding(7)
-                    .width(Fill)
-                    .style(if self.selected.as_ref() == Some(&fact.selector) {
-                        style::selected
-                    } else {
-                        style::nav
-                    })
-                    .on_press(event(Event::Select(fact.selector.clone()))),
-                );
-            }
-        }
-        row![
-            scrollable(list).height(305).width(260),
-            scrollable(self.detail(project)).height(305).width(Fill)
-        ]
-        .spacing(12)
-        .into()
-    }
-
-    fn detail<'a>(&'a self, project: &'a Project) -> Element<'a, Message> {
-        let Some(fact) = self
-            .selected
-            .as_ref()
-            .and_then(|s| self.facts.iter().find(|f| &f.selector == s))
-        else {
-            return text("Choose a trace and property to compare.")
-                .size(13)
-                .into();
-        };
-        let trace = self.trace.and_then(|id| project.traces.get(&id));
-        let previous = trace
-            .and_then(|t| t.baseline.as_ref())
-            .and_then(|b| b.semantic.as_ref())
-            .and_then(|b| b.facets.iter().find(|f| f.selector() == fact.selector));
-        let is_group = scalar::grouped(&fact.selector);
-        let group_observations = |project: &Project, facts: Vec<&FacetReview>, layer| {
-            facts
-                .into_iter()
-                .filter(|f| constructors::contains(&fact.selector, &f.selector()))
-                .map(|f| {
-                    format!(
-                        "{}: {}",
-                        title(project, &f.selector()),
-                        observed(project, Some(f), layer)
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join("\n")
-        };
-        let side = |layer, label: &str| {
-            let mut before = observed(project, previous, layer);
-            let mut current = observed(project, Some(&fact.current), layer);
-            if is_group {
-                before = group_observations(
-                    project,
-                    trace
-                        .and_then(|t| t.baseline.as_ref())
-                        .and_then(|b| b.semantic.as_ref())
-                        .map(|b| b.facets.iter().collect())
-                        .unwrap_or_default(),
-                    layer,
-                );
-                if before.is_empty() {
-                    before = "No previous group observations".into();
-                }
-                current = group_observations(
-                    project,
-                    self.facts.iter().map(|f| &f.current).collect(),
-                    layer,
-                );
-            }
-            column![
-                text(format!(
-                    "{label}{}",
-                    if layer == self.direction.target_layer() {
-                        " · destination"
-                    } else {
-                        " · source"
-                    }
-                ))
-                .size(12)
-                .color(style::TEAL),
-                text("Previously reviewed").size(10).color(style::MUTED),
-                text(before).size(12),
-                text("Current").size(10).color(style::MUTED),
-                text(current).size(12),
-            ]
-            .spacing(5)
-            .width(Fill)
-        };
-        let mut detail = column![
-            text(title(project, &fact.selector)).size(17),
-            text(drift(fact.drift)).size(11),
-            row![side(Layer::Oa, "Operational"), side(Layer::Sa, "System")].spacing(14)
-        ]
-        .spacing(10);
-        if previous.is_some() && history::resettable(&fact.selector) {
-            let facet = fact.selector.clone();
-            detail = detail.push(
-                checkbox(self.resets.contains(&facet))
-                    .label("Reset this exact previous observation before review")
-                    .text_size(11)
-                    .on_toggle(move |v| event(Event::Reset(facet.clone(), v))),
-            );
-        }
-        if keyed::supported(&fact.selector) {
-            detail = detail.push(text("Presence changes only this collection entry; referenced objects stay intact. Take preserves a row with no source identity. An explicit source identity that is absent can remove its mapped destination entry.").size(11))
-                .push(action("Choose / change exact row identities…", Event::EditPair(fact.selector.clone())));
-            if let Some(baseline) = trace
-                .and_then(|t| t.baseline.as_ref())
-                .and_then(|b| b.semantic.as_ref())
-            {
-                for prior in &baseline.facets {
-                    let prior = prior.selector();
-                    if prior != fact.selector && keyed::overlap(&prior, &fact.selector) {
-                        detail = detail.push(
-                            checkbox(self.resets.contains(&prior))
-                                .label(format!(
-                                    "Reset overlapping history: {}",
-                                    title(project, &prior)
-                                ))
-                                .text_size(11)
-                                .on_toggle(move |v| event(Event::Reset(prior.clone(), v))),
-                        );
-                    }
-                }
-            }
-        }
-        if let Some(proposed) = &self.proposed
-            && let Some(trace) = trace
-            && let Ok(after) = capture_facet(proposed, trace.oa, trace.sa, &fact.selector)
-        {
-            detail = detail
-                .push(
-                    text("Proposed destination value · validated preview")
-                        .size(11)
-                        .color(style::TEAL),
-                )
-                .push(
-                    text(if is_group {
-                        semantic_facets(proposed, &proposed.traces[&trace.id], &self.references)
-                            .ok()
-                            .map(|facts| {
-                                group_observations(
-                                    proposed,
-                                    facts.iter().map(|f| &f.current).collect(),
-                                    self.direction.target_layer(),
-                                )
-                            })
-                            .unwrap_or_else(|| "Group payload is unavailable.".into())
-                    } else {
-                        observed(proposed, Some(&after), self.direction.target_layer())
-                    })
-                    .size(12),
-                );
-        } else {
-            detail = detail.push(
-                text("No validated final preview. Resolve the messages below before applying.")
-                    .size(11)
-                    .color(style::MUTED),
-            );
-        }
-        if self.editable(project, &fact.selector) {
-            if is_group {
-                detail = detail.push(text(constructors::description(&fact.selector)).size(12));
-                detail = detail.push(text("Replacing a kind reviews its complete payload. Review every removed reference, row and prior observation in the exact scope below; changing kind retains your draft for switching back.").size(11));
-                if self.can_acknowledge_constructor(project, &fact.selector) {
-                    detail = detail.push(text("These initial kinds are equal. Keep or Take acknowledges only the kind; an unchanged Candidate kind needs independent descendant decisions for payload edits.").size(11).color(style::MUTED));
-                }
-            }
-            let destination = if self.direction.target_layer() == Layer::Sa {
-                "System"
-            } else {
-                "Operational"
-            };
-            let source = if self.direction.source_layer() == Layer::Oa {
-                "Operational"
-            } else {
-                "System"
-            };
-            let mut buttons = row![
-                action(
-                    format!("Keep {destination}"),
-                    Event::Decide(fact.selector.clone(), Some(SemanticDecision::KeepTarget))
-                ),
-                action(
-                    format!("Take {source}"),
-                    Event::Decide(fact.selector.clone(), Some(SemanticDecision::TakeSource))
-                )
-            ]
-            .spacing(5);
-            buttons = buttons.push(action(
-                if is_group {
-                    "Set final kind and payload…"
-                } else {
-                    "Set final value…"
-                },
-                Event::Decide(fact.selector.clone(), Some(SemanticDecision::Candidate)),
-            ));
-            detail = detail.push(buttons.wrap()).push(action(
-                "Leave unselected",
-                Event::Decide(fact.selector.clone(), None),
-            ));
-            if self.decisions.get(&fact.selector) == Some(&SemanticDecision::Candidate)
-                && keyed::supported(&fact.selector)
-            {
-                let facet = fact.selector.clone();
-                detail = detail.push(
-                    checkbox(self.presence.get(&facet).copied().unwrap_or(false))
-                        .label(
-                            "Include in destination collection (unchecked removes only this entry)",
-                        )
-                        .text_size(12)
-                        .on_toggle(move |v| event(Event::Presence(facet.clone(), v))),
-                );
-            }
-            if self.decisions.get(&fact.selector) == Some(&SemanticDecision::Candidate)
-                && let Some(draft) = self.candidate_draft(&fact.selector)
-                && let Some(paths) = self
-                    .target(project)
-                    .and_then(|id| constructors::roots(project, id, &fact.selector))
-            {
-                detail = detail.push(text("Final destination value").size(12));
-                for path in paths {
-                    let label = if path.ends_with("/default") {
-                        "Default"
-                    } else if path.ends_with("/legacy") {
-                        "Generic association"
-                    } else {
-                        "Kind and payload"
-                    };
-                    detail = detail.push(
-                        crate::forms::scoped(
-                            draft,
-                            project,
-                            &path,
-                            if is_group { label } else { "Final value" },
-                        )
-                        .map(form_event),
-                    );
-                }
-            }
-        } else if self.can_acknowledge_constructor(project, &fact.selector) {
-            detail = detail.push(text("Both constructor kinds are equal and have no prior observation. Acknowledge only the kind; its properties remain independent.").size(12))
-                .push(action("Acknowledge equal kind only", Event::Decide(fact.selector.clone(), Some(SemanticDecision::KeepTarget))))
-                .push(action("Leave unselected", Event::Decide(fact.selector.clone(), None)));
-        } else {
-            detail = detail.push(text(if scalar::grouped(&fact.selector) { "This constructor is unavailable on one of the current counterparts. Review the outer constructor before its nested kind." } else { "This structured or inapplicable fact is read-only here. Its review history is retained." }).size(12).color(style::MUTED));
-        }
-        if self.staged.contains(&fact.selector) {
-            detail = detail.push(action(
-                "Remove staged address and its decision",
-                Event::DropStaged(fact.selector.clone()),
-            ));
-        }
-        let overlaps: Vec<_> = self
-            .decisions
-            .keys()
-            .filter(|other| {
-                **other != fact.selector
-                    && (constructors::contains(&fact.selector, other)
-                        || constructors::contains(other, &fact.selector)
-                        || keyed::overlap(other, &fact.selector))
-            })
-            .collect();
-        if self.decisions.contains_key(&fact.selector) && !overlaps.is_empty() {
-            detail = detail.push(text("Related decisions are selected. Paired rows cannot review the same OA or SA identity twice. Replacing groups require one combined decision; first equal-kind acknowledgments may coexist with descendants. Resolve overlaps explicitly; all drafts are retained.").size(11));
-            for other in overlaps {
-                detail = detail.push(action(
-                    format!("Leave {} unselected", title(project, other)),
-                    Event::Decide(other.clone(), None),
-                ));
-            }
-            detail = detail.push(action(
-                "Leave this decision unselected; use the related decisions",
-                Event::Decide(fact.selector.clone(), None),
-            ));
-        }
-        if (is_group
-            || keyed::supported(&fact.selector)
-            || constructors::selectors().iter().any(|group| {
-                self.decisions.contains_key(group) && constructors::contains(group, &fact.selector)
-            }))
-            && let Some(review) = self.plan.as_ref().and_then(|p| p.reviews.first())
-        {
-            detail = detail.push(text("Exact review scope from preview").size(13));
-            for (label, selectors) in [
-                ("Acknowledge", &review.acknowledged),
-                ("Retire previous observation", &review.retired),
-            ] {
-                detail = detail.push(
-                    text(format!(
-                        "{label}: {}",
-                        if selectors.is_empty() {
-                            "None".into()
-                        } else {
-                            selectors
-                                .iter()
-                                .map(|s| title(project, s))
-                                .collect::<Vec<_>>()
-                                .join(", ")
-                        }
-                    ))
-                    .size(11),
-                );
-            }
-        }
-        if matches!(
-            fact.selector,
-            FacetSelector::Child(_)
-                | FacetSelector::Incident { .. }
-                | FacetSelector::Artifact { .. }
-        ) {
-            detail = detail.push(text("Attached facts are separate from referenced definitions. Removing membership never implies deleting a semantic object.").size(11).color(style::MUTED));
-        }
-        detail.into()
-    }
-
-    fn members_view<'a>(&'a self, project: &'a Project) -> Element<'a, Message> {
-        let families = self.member_families(project);
-        let available = families.contains(&self.member_family);
-        let mut content = column![
-            text("Review an individual member or literal").size(16),
-            text("Choose an address, then review its presence in Properties. This also stages a new row in an empty collection. No model object is created.").size(12),
-            pick_list(families, Some(self.member_family), |v| event(Event::MemberFamily(v))).text_size(12).padding(7),
-        ].spacing(9);
-        if !available {
-            content = content.push(text("This collection is not available on the current counterparts. Choose an available collection above; existing staged addresses remain removable below.").size(12));
-        } else if self.member_family == keyed::Family::Literal {
-            content = content.push(text("Literal identity is exact, including case and spaces. Both sides use the same string; a rename requires separate old/new rows.").size(11))
-                .push(text_input("Exact literal", &self.literal).on_input(|v| event(Event::Literal(v))).size(12).padding(7))
-                .push(row![checkbox(self.literal_oa).label("Operational identity").text_size(12).on_toggle(|v| event(Event::LiteralSide(Layer::Oa,v))), checkbox(self.literal_sa).label("System identity").text_size(12).on_toggle(|v| event(Event::LiteralSide(Layer::Sa,v)))].spacing(12));
-        } else {
-            content = content.push(text("Identities may exist outside the collection. Choosing both explicitly sets their OA → SA correspondence. No identity means an unpaired side, distinct from an absent member.").size(11))
-                .push(row![pick_list(self.member_choices(project, Layer::Oa), self.member_oa.clone(), |v| event(Event::MemberOa(Some(v)))).placeholder("Operational identity").text_size(12).padding(7).width(Fill), action("No OA identity", Event::MemberOa(None))].spacing(7))
-                .push(row![pick_list(self.member_choices(project, Layer::Sa), self.member_sa.clone(), |v| event(Event::MemberSa(Some(v)))).placeholder("System identity").text_size(12).padding(7).width(Fill), action("No SA identity", Event::MemberSa(None))].spacing(7));
-        }
-        content = content.push(button(text("Use these identities and review presence").size(12)).padding([7,9]).style(style::nav).on_press_maybe(available.then_some(event(Event::StageMember))))
-            .push(text("Changing a row address retains its earlier decisions and drafts. Reset conflicting historical observations and leave overlapping decisions unselected explicitly.").size(11).color(style::MUTED));
-        if !self.staged.is_empty() {
-            content = content.push(text("Staged addresses in this draft").size(13));
-            for facet in &self.staged {
-                content = content.push(
-                    row![
-                        text(title(project, facet)).size(11).width(Fill),
-                        action(
-                            "Remove address / decision",
-                            Event::DropStaged(facet.clone())
-                        )
-                    ]
-                    .spacing(7),
-                );
-            }
-        }
-        scrollable(content).height(305).into()
-    }
-
-    fn history_view<'a>(&'a self, project: &'a Project) -> Element<'a, Message> {
-        let mut content = column![text("Exact previous observations").size(16), text("Check only the observations to forget. Resets run before this review's decisions; reset alone changes history, not model values. Uncheck to restore the pending observation. Prose history remains separate.").size(12)].spacing(9);
-        let baseline = self
-            .trace
-            .and_then(|id| project.traces.get(&id))
-            .and_then(|t| t.baseline.as_ref())
-            .and_then(|b| b.semantic.as_ref());
-        if baseline.is_none_or(|b| b.facets.is_empty()) {
-            content =
-                content.push(text("No previous semantic observations on this trace.").size(12));
-        }
-        if let Some(baseline) = baseline {
-            for fact in &baseline.facets {
-                let facet = fact.selector();
-                let mut item = column![
-                    text(title(project, &facet)).size(13),
-                    text(format!(
-                        "Operational: {}\nSystem: {}",
-                        observed(project, Some(fact), Layer::Oa),
-                        observed(project, Some(fact), Layer::Sa)
-                    ))
-                    .size(11)
-                ]
-                .spacing(4);
-                if history::resettable(&facet) {
-                    item = item.push(
-                        checkbox(self.resets.contains(&facet))
-                            .label("Reset this exact observation")
-                            .text_size(11)
-                            .on_toggle(move |v| event(Event::Reset(facet.clone(), v))),
-                    );
-                } else {
-                    item = item.push(
-                        text("Artifact history reset remains pending with artifact review.")
-                            .size(11),
-                    );
-                }
-                content = content.push(container(item).padding(7));
-            }
-        }
-        for pending in &self.resets {
-            if baseline.is_none_or(|b| !b.facets.iter().any(|f| f.selector() == *pending)) {
-                let facet = pending.clone();
-                content = content.push(
-                    checkbox(true)
-                        .label(format!(
-                            "Pending reset no longer in current history: {}",
-                            title(project, &facet)
-                        ))
-                        .text_size(11)
-                        .on_toggle(move |v| event(Event::Reset(facet.clone(), v))),
-                );
-            }
-        }
-        scrollable(content).height(305).into()
-    }
-
-    fn references_view<'a>(&'a self, project: &'a Project) -> Element<'a, Message> {
-        let mut content = column![
-            text("Reference correspondence · always Operational → System").size(15),
-            text("Choose explicit counterpart identities before taking reference values. Names do not establish correspondence. Changing an already reviewed keyed pair requires an exact reset in History. Existing decisions are retained; resolve their overlapping row identities explicitly.").size(12),
-            text_input("Filter reference choices by name or alias", &self.reference_search).on_input(|v| event(Event::ReferenceSearch(v))).padding(7).size(12),
-            row![
-                pick_list(self.all_references(project, Layer::Oa), self.reference_oa.clone(), |c| event(Event::ReferenceOa(c))).placeholder("Operational reference").padding(7).text_size(12).width(Fill),
-                pick_list(self.all_references(project, Layer::Sa), self.reference_sa.clone(), |c| event(Event::ReferenceSa(c))).placeholder("System reference").padding(7).text_size(12).width(Fill),
-                action("Use pair", Event::AddReference),
-            ].spacing(7),
-        ].spacing(9);
-        for (oa, sa) in &self.references {
-            content = content.push(
-                row![
-                    text(format!(
-                        "{}\n↔ {}",
-                        choice(project, *oa).label,
-                        choice(project, *sa).label
-                    ))
-                    .size(12)
-                    .width(Fill),
-                    action("Remove pair", Event::RemoveReference(*oa))
-                ]
-                .spacing(6),
-            );
-        }
-        if let Some(trace) = self.trace.and_then(|id| project.traces.get(&id)) {
-            content = content
-                .push(text("Referenced definitions · reviewed on their own traces").size(14));
-            match linked_semantic_impacts(project, trace, &self.references) {
-                Ok(impacts) => {
-                    for impact in impacts {
-                        content = content.push(
-                            text(format!(
-                                "{} ↔ {} · {}{} · {} trace(s)",
-                                impact
-                                    .objects
-                                    .oa
-                                    .map(|id| choice(project, id).label)
-                                    .unwrap_or_else(|| "Absent".into()),
-                                impact
-                                    .objects
-                                    .sa
-                                    .map(|id| choice(project, id).label)
-                                    .unwrap_or_else(|| "Absent".into()),
-                                drift(impact.drift),
-                                if impact.unreviewed {
-                                    " · incomplete review"
-                                } else {
-                                    ""
-                                },
-                                impact.traces.len()
-                            ))
-                            .size(12),
-                        );
-                    }
-                }
-                Err(error) => content = content.push(text(error).size(12)),
-            }
-        }
-        scrollable(content).height(305).into()
-    }
-
-    fn impacts_view<'a>(&'a self, project: &'a Project) -> Element<'a, Message> {
-        let mut content = column![text("Additional prepared changes").size(16), text("Accept each exact change required by model preparation. Acceptance never overrides a selected Keep or Take. Editing a decision clears these approvals.").size(12)].spacing(10);
-        if let Some(plan) = &self.plan {
-            if plan.impacts.is_empty() {
-                content =
-                    content.push(text("No additional prepared changes in this preview.").size(12));
-            }
-            for (index, impact) in plan.impacts.iter().enumerate() {
-                let before = impact
-                    .before
-                    .as_ref()
-                    .map(|r| serde_json::to_value(r).expect("Typed impact"));
-                let after = impact
-                    .after
-                    .as_ref()
-                    .map(|r| serde_json::to_value(r).expect("Typed impact"));
-                let ids = project.identities().into_iter().map(|(id, _)| id).collect();
-                content = content.push(
-                    container(
-                        column![
-                            checkbox(self.accepted_impacts.contains(impact))
-                                .label(format!("Accept · {}", project.named(impact.object)))
-                                .text_size(12)
-                                .on_toggle(move |accepted| event(Event::AcceptImpact(
-                                    index, accepted
-                                ))),
-                            text("Before").size(11).color(style::MUTED),
-                            text(
-                                before
-                                    .as_ref()
-                                    .map(|v| formatted(project, v, &ids))
-                                    .unwrap_or_else(|| "Absent · record creation".into())
-                            )
-                            .size(12),
-                            text("After").size(11).color(style::MUTED),
-                            text(
-                                after
-                                    .as_ref()
-                                    .map(|v| formatted(project, v, &ids))
-                                    .unwrap_or_else(|| "Absent · record deletion".into())
-                            )
-                            .size(12),
-                        ]
-                        .spacing(6),
-                    )
-                    .padding(10)
-                    .style(style::subtle),
-                );
-            }
-        }
-        scrollable(content).height(305).into()
-    }
-}

crates/oa-desktop/src/tests.rs

@@ -250,10 +250,7 @@ fn opening_legacy_source_surfaces_report_without_modifying_original_bytes() {
     assert_eq!(app.page, Page::Validation);
     assert_eq!(app.project(), &original);
     assert!(!app.dirty());
-    assert!(
-        app.source_snapshot
-            .starts_with(&format!("arcadia {SCHEMA_VERSION};"))
-    );
+    assert!(app.source_snapshot.starts_with("arcadia 3;"));
     assert!(serde_json::from_slice::<serde_json::Value>(&bytes).unwrap()["schema_version"] == 2);
 }
 

crates/oa-desktop/src/views.rs

@@ -247,13 +247,6 @@ pub fn view(app: &App) -> View<'_, Message> {
     .style(style::panel);
     let root: View<'_, Message> = column![header, task_nav, body, footer].into();
     if let Some(workflow) = &app.workflow {
-        if matches!(workflow, crate::workflow::Workflow::Semantic(_)) {
-            return modal_width(
-                root,
-                workflow.view(p),
-                (app.window_size.width - 50.).clamp(800., 1120.),
-            );
-        }
         return modal(root, workflow.view(p));
     }
     if let Some(p) = &app.file_prompt {
@@ -306,27 +299,15 @@ pub fn view(app: &App) -> View<'_, Message> {
     root
 }
 fn modal<'a>(base: View<'a, Message>, content: View<'a, Message>) -> View<'a, Message> {
-    modal_width(base, content, 800.)
-}
-fn modal_width<'a>(
-    base: View<'a, Message>,
-    content: View<'a, Message>,
-    width: f32,
-) -> View<'a, Message> {
     widget::stack![
         base,
         widget::opaque(
-            container(
-                container(content)
-                    .padding(26)
-                    .width(width)
-                    .style(style::card)
-            )
-            .center(Fill)
-            .style(|_| container::Style {
-                background: Some(iced::Color::from_rgba(0.08, 0.12, 0.18, 0.38).into()),
-                ..Default::default()
-            })
+            container(container(content).padding(26).width(800).style(style::card))
+                .center(Fill)
+                .style(|_| container::Style {
+                    background: Some(iced::Color::from_rgba(0.08, 0.12, 0.18, 0.38).into()),
+                    ..Default::default()
+                })
         )
     ]
     .into()
@@ -722,7 +703,69 @@ fn inspector(app: &App) -> View<'_, Message> {
 }
 
 fn data_catalog(app: &App) -> View<'_, Message> {
-    crate::data_view::view(app)
+    let p = app.project();
+    let mut content = column![heading(
+        "Data & interfaces",
+        "Define information, material and energy at the system boundary."
+    )]
+    .spacing(15);
+    for kind in Kind::ALL {
+        let is_data = matches!(
+            kind,
+            Kind::ExchangeItem | Kind::DataType | Kind::DataField | Kind::Interface | Kind::Port
+        );
+        if !is_data {
+            continue;
+        }
+        let elements = p
+            .elements
+            .values()
+            .filter(|e| e.layer() == app.layer && e.kind() == kind)
+            .collect::<Vec<_>>();
+        if elements.is_empty() {
+            continue;
+        }
+        content = content.push(
+            text(format!("{} · {}", kind.label(), elements.len()))
+                .size(15)
+                .color(style::kind_color(kind)),
+        );
+        for e in elements {
+            content = content.push(crate::context_menu::Area::new(
+                button(
+                    row![
+                        column![
+                            text(&e.name).size(14),
+                            label(format!(
+                                "@{}{}",
+                                e.alias,
+                                e.parent
+                                    .map(|id| format!(" · in {}", p.named(id)))
+                                    .unwrap_or_default()
+                            )),
+                            text(short(&e.description, 125))
+                                .size(12)
+                                .color(style::MUTED)
+                        ]
+                        .spacing(5)
+                        .width(Fill),
+                        text("→").size(17)
+                    ]
+                    .align_y(iced::Center),
+                )
+                .padding(14)
+                .width(Fill)
+                .style(if e.id == app.selected {
+                    style::selected
+                } else {
+                    style::nav
+                })
+                .on_press(Message::Select(e.id)),
+                move |anchor| crate::model_menu::open(e.id, anchor),
+            ));
+        }
+    }
+    scrollable(content.padding(24)).into()
 }
 
 fn traces(app: &App) -> View<'_, Message> {
@@ -733,18 +776,13 @@ fn traces(app: &App) -> View<'_, Message> {
             "Connect operational needs, system responsibilities and development evidence."
         ),
         row![
-            button(text("Create counterpart / review prose…").size(12))
+            button(text("Create / update counterpart…").size(12))
                 .padding(9)
                 .on_press(Message::StartTransition),
             action("+ Manual trace", Message::AddTrace),
-            action(
-                "Review semantics…",
-                Message::StartSemanticReview(app.selected)
-            ),
             action("+ Artifact", Message::AddArtifact)
         ]
         .spacing(8)
-        .wrap()
     ]
     .spacing(16);
     for t in p.traces.values() {
@@ -764,14 +802,10 @@ fn traces(app: &App) -> View<'_, Message> {
                     .spacing(8)
                     .align_y(iced::Center),
                     row![
-                        label(format!("{:?} · Prose: {current}", t.kind)),
+                        label(format!("{:?} · {current}", t.kind)),
                         Space::new().width(Fill),
-                        action("Review semantics…", Message::StartSemanticReview(t.id)),
-                        action("Edit link", Message::Select(t.id))
+                        action("Review link", Message::Select(t.id))
                     ],
-                    text(crate::semantic_review::summary(p, t))
-                        .size(11)
-                        .color(style::MUTED),
                     text(short(&t.description, 130)).size(12)
                 ]
                 .spacing(10),
@@ -1065,51 +1099,6 @@ fn checks(app: &App) -> View<'_, Message> {
                     app.project().named(endpoint.exchange)
                 )));
         }
-        card=card.push(label(format!("Data migration: {} semantic defaults · {} interface allocations · {} unresolved value addresses",report.semantic_defaults.len(),report.generated_interface_allocations.len(),report.unresolved_message_values.len())));
-        for default in report.semantic_defaults.iter().take(6) {
-            card = card
-                .push(action(
-                    &format!(
-                        "{} · {}",
-                        app.project().named(default.object),
-                        default.field
-                    ),
-                    Message::Select(default.object),
-                ))
-                .push(label(&default.description));
-        }
-        for allocation in report.generated_interface_allocations.iter().take(6) {
-            card = card
-                .push(action(
-                    &format!(
-                        "Created item allocation · @{} · order {}",
-                        allocation.alias, allocation.order
-                    ),
-                    Message::Select(allocation.id),
-                ))
-                .push(label(format!(
-                    "{} → {}",
-                    app.project().named(allocation.source),
-                    app.project().named(allocation.target)
-                )));
-        }
-        for value in report.unresolved_message_values.iter().take(6) {
-            card = card
-                .push(action(
-                    &format!(
-                        "Review qualified value · {}",
-                        app.project().named(value.occurrence)
-                    ),
-                    Message::EditProperties(value.occurrence),
-                ))
-                .push(label(&value.reason));
-        }
-        if report.semantic_defaults.len() > 6
-            || report.generated_interface_allocations.len() > 6
-            || report.unresolved_message_values.len() > 6
-        {
-            card=card.push(label("Showing the first six entries in each data migration category. Model checks below link remaining unresolved contracts."));
-        }
         for boundary in &report.orientation_defaults {
             card = card.push(action(
                 &format!(

crates/oa-desktop/src/workflow.rs

@@ -15,7 +15,6 @@ use std::collections::BTreeSet;
 
 #[derive(Debug, Clone)]
 pub enum Event {
-    Semantic(crate::semantic_review::Event),
     Port(crate::port_workflow::Event),
     ExchangeItem(Id, bool),
     Endpoint(bool, EndpointChoice),
@@ -34,7 +33,6 @@ pub enum Event {
     Preview,
 }
 pub enum Workflow {
-    Semantic(Box<crate::semantic_review::State>),
     Ports(Box<crate::port_workflow::State>),
     Relation(Box<Relationship>),
     ManualTrace {
@@ -335,11 +333,6 @@ impl Workflow {
     /// choices and previews never mutate the Session.
     pub fn update(&mut self, p: &Project, event: Event) -> Result<Option<Project>, String> {
         match self {
-            Self::Semantic(_) => {
-                return Err(
-                    "Semantic review commits its exact command batch through Document.".into(),
-                );
-            }
             Self::Ports(state) => return state.update(p, event),
             Self::ManualTrace {
                 name,
@@ -578,7 +571,6 @@ impl Workflow {
     }
     pub fn title(&self) -> &'static str {
         match self {
-            Self::Semantic(_) => "Review semantics",
             Self::Ports(state) => state.title(),
             Self::ManualTrace { .. } => "Link existing counterparts",
             Self::Relation(_) => "Create relationship",
@@ -592,9 +584,6 @@ impl Workflow {
         }
     }
     pub fn view<'a>(&'a self, p: &'a Project) -> Element<'a, Message> {
-        if let Self::Semantic(state) = self {
-            return state.view(p);
-        }
         if let Self::Ports(state) = self {
             return state.view(p);
         }
@@ -605,7 +594,7 @@ impl Workflow {
             None
         };
         match self {
-            Self::Ports(_) | Self::Semantic(_) => unreachable!("Dedicated dialog returned above"),
+            Self::Ports(_) => unreachable!("Port dialog returned above"),
             Self::ManualTrace {
                 name,
                 source,
@@ -1084,7 +1073,6 @@ impl Workflow {
             }
         }
         let enabled = match self {
-            Self::Semantic(_) => false,
             Self::Ports(_) => false,
             Self::ManualTrace { name, target, .. } => target.is_some() && !name.trim().is_empty(),
             Self::Relation(_) => relation_plan.as_ref().is_some_and(Result::is_ok),

crates/oa-server/src/routes.rs

@@ -72,18 +72,6 @@ pub(crate) fn router() -> Router<AppState> {
             "/api/v1/projects/{id}/transitions/apply",
             post(commit_transition),
         )
-        .route(
-            "/api/v1/projects/{id}/semantic-transitions/query",
-            post(query_semantic_transitions),
-        )
-        .route(
-            "/api/v1/projects/{id}/semantic-transitions/preview",
-            post(preview_semantic_transition),
-        )
-        .route(
-            "/api/v1/projects/{id}/semantic-transitions/apply",
-            post(commit_semantic_transition),
-        )
         .fallback(|| async {
             ApiError::new(
                 StatusCode::NOT_FOUND,
@@ -243,7 +231,7 @@ fn parse_source(body: &[u8]) -> ApiResult<oa_core::persistence::DecodeResult> {
 }
 
 fn import_json(body: &[u8]) -> ApiResult<oa_core::persistence::DecodeResult> {
-    // Format is chosen by HTTP. The shared decoder owns supported older-schema migration.
+    // Format is chosen by HTTP. The shared decoder owns explicit schema-1 and schema-2 migration.
     let _: Value = json_body(body)?;
     oa_core::persistence::decode_with_report_limited(body, MODEL_LIMITS).map_err(
         |error| match error {
@@ -537,7 +525,7 @@ async fn put_source_project(
             StatusCode::OK,
             json!({
                 "revision": stored.revision, "changed": changed, "issues": diagnostics,
-                "source_project": stored.source_project, "migration": stored.migration
+                "source_project": stored.source_project
             }),
         ))
     })
@@ -959,16 +947,14 @@ async fn validate_candidate(
                     // Advisory locations refer to submitted bytes, before Apply
                     // would insert missing persistent identities.
                     let diagnostics: Vec<_> = source_project::lint_bundle(&source_project, SOURCE_LIMITS).into_iter().map(source_issue).collect();
-                    let migration = if !diagnostics.iter().any(|issue| issue.severity == "error") {
-                        PreparedProject::from_bundle(source_project)?.migration().cloned()
-                    } else {
-                        None
-                    };
-                    Ok((diagnostics, migration))
+                    if !diagnostics.iter().any(|issue| issue.severity == "error") {
+                        PreparedProject::from_bundle(source_project)?;
+                    }
+                    Ok(diagnostics)
                 });
-                let (diagnostics, migration) = result.unwrap_or_else(|error| (candidate_issues(error), None));
+                let diagnostics = result.unwrap_or_else(candidate_issues);
                 let valid = !diagnostics.iter().any(|issue| issue.severity == "error");
-                return Ok(response(stored, StatusCode::OK, json!({"revision":stored.revision,"valid":valid,"issues":diagnostics,"migration":migration})));
+                return Ok(response(stored, StatusCode::OK, json!({"revision":stored.revision,"valid":valid,"issues":diagnostics,"migration":null})));
             }
             _ => return Err(ApiError::bad_request("Validation requires one matching format/payload: json with model, arcadia with source, or source-project with source_project.")),
         };
@@ -1101,164 +1087,6 @@ struct TransitionApplyRequest {
     plan: oa_core::transitions::TransitionPlan,
 }
 
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-struct SemanticQueryRequest {
-    traces: Vec<Id>,
-    #[serde(default)]
-    references: BTreeMap<Id, Id>,
-    revision: Option<u64>,
-}
-
-fn semantic_rejected(error: impl std::fmt::Display) -> ApiError {
-    ApiError::new(
-        StatusCode::UNPROCESSABLE_ENTITY,
-        "semantic_transition_rejected",
-        error.to_string(),
-    )
-}
-
-async fn query_semantic_transitions(
-    State(state): State<AppState>,
-    id: ProjectPath,
-    headers: HeaderMap,
-    body: Body,
-) -> ApiResult<Response> {
-    let id = path(id)?;
-    media(&headers, "application/json")?;
-    let body = bytes(body)?;
-    blocking(state, move |store| {
-        let request: SemanticQueryRequest = json_body(&body)?;
-        if request.traces.is_empty() || request.traces.len() > 100 || request.references.len() > 5_000 {
-            return Err(ApiError::bad_request("Semantic queries require 1–100 trace IDs and at most 5,000 reference mappings."));
-        }
-        let selected: BTreeSet<_> = request.traces.iter().copied().collect();
-        if selected.len() != request.traces.len() {
-            return Err(ApiError::bad_request("Semantic query trace IDs must be unique."));
-        }
-        let current = store.get(id)?;
-        check_read_revision(&current, request.revision)?;
-        let mut items = Vec::new();
-        for trace_id in request.traces {
-            let trace = current.model.traces.get(&trace_id).ok_or_else(|| {
-                ApiError::new(StatusCode::NOT_FOUND, "trace_not_found", "Selected trace does not exist.")
-            })?;
-            let facets = oa_core::semantic::semantic_facets(&current.model, trace, &request.references)
-                .map_err(semantic_rejected)?;
-            let drift = oa_core::semantic::trace_semantic_drift(&current.model, trace, &request.references)
-                .map_err(semantic_rejected)?;
-            let linked_impacts = oa_core::semantic::linked_semantic_impacts(&current.model, trace, &request.references)
-                .map_err(semantic_rejected)?;
-            items.push(json!({"trace":trace.id,"oa":trace.oa,"sa":trace.sa,"facets":facets,"drift":drift,"linked_impacts":linked_impacts}));
-        }
-        Ok(response(&current, StatusCode::OK, json!({"revision":current.revision,"items":items})))
-    }).await
-}
-
-fn check_semantic_request(request: &oa_core::semantic::SemanticTransitionRequest) -> ApiResult<()> {
-    let transition = &request.transition;
-    let decisions = request.reviews.iter().try_fold(0usize, |count, review| {
-        count
-            .checked_add(review.resolutions.len())?
-            .checked_add(review.reset.len())
-    });
-    if transition.sources.len() > 100
-        || transition.mappings.len() > 200
-        || transition.resolutions.len() > 400
-        || request.traces.len() > 100
-        || request.references.len() > 5_000
-        || request.reviews.len() > 100
-        || decisions.is_none_or(|count| count > 5_000)
-        || request.candidates.len() > 200
-        || request.accepted_impacts.len() > 200
-    {
-        return Err(ApiError::bad_request(
-            "Semantic transitions allow at most 100 sources/traces/reviews, 200 mappings/candidates/accepted impacts, 400 prose resolutions and 5,000 reference mappings or combined facet resolutions/resets.",
-        ));
-    }
-    Ok(())
-}
-
-async fn preview_semantic_transition(
-    State(state): State<AppState>,
-    id: ProjectPath,
-    headers: HeaderMap,
-    body: Body,
-) -> ApiResult<Response> {
-    let id = path(id)?;
-    let expected = expected(&headers)?;
-    media(&headers, "application/json")?;
-    let body = bytes(body)?;
-    blocking(state, move |store| {
-        let request: oa_core::semantic::SemanticTransitionRequest = json_body(&body)?;
-        check_semantic_request(&request)?;
-        let current = store.checked(id, &expected)?;
-        let plan = oa_core::semantic::plan_semantic_transition(&current.model, request)
-            .map_err(semantic_rejected)?;
-        if !plan.commands.is_empty() {
-            check_commands(&plan.commands)?;
-        }
-        if plan.conflicts.is_empty() {
-            let candidate = oa_core::semantic::prepare_semantic_transition(&current.model, &plan)
-                .map_err(semantic_rejected)?;
-            PreparedProject::from_command(&current, candidate)?;
-        }
-        Ok(response(
-            &current,
-            StatusCode::OK,
-            json!({"base_revision":current.revision,"plan":plan}),
-        ))
-    })
-    .await
-}
-
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-struct SemanticApplyRequest {
-    base_revision: u64,
-    plan: oa_core::semantic::SemanticTransitionPlan,
-}
-
-async fn commit_semantic_transition(
-    State(state): State<AppState>,
-    id: ProjectPath,
-    headers: HeaderMap,
-    body: Body,
-) -> ApiResult<Response> {
-    let id = path(id)?;
-    let expected = expected(&headers)?;
-    media(&headers, "application/json")?;
-    let body = bytes(body)?;
-    blocking(state, move |store| {
-        let request: SemanticApplyRequest = json_body(&body)?;
-        let current = store.checked(id, &expected)?;
-        if current.revision != request.base_revision {
-            let mut error = ApiError::new(
-                StatusCode::PRECONDITION_FAILED,
-                "plan_revision_conflict",
-                "Semantic preview revision changed. Create a new preview.",
-            );
-            error.current_revision = Some(current.revision);
-            return Err(error);
-        }
-        check_semantic_request(&request.plan.request)?;
-        if !request.plan.commands.is_empty() {
-            check_commands(&request.plan.commands)?;
-        }
-        let candidate =
-            oa_core::semantic::prepare_semantic_transition(&current.model, &request.plan)
-                .map_err(semantic_rejected)?;
-        let prepared = PreparedProject::from_command(&current, candidate)?;
-        let (stored, changed) = store.replace(id, &expected, prepared)?;
-        Ok(response(
-            &stored,
-            StatusCode::OK,
-            json!({"revision":stored.revision,"changed":changed,"issues":issues(&stored.model)}),
-        ))
-    })
-    .await
-}
-
 async fn commit_transition(
     State(state): State<AppState>,
     id: ProjectPath,

crates/oa-server/src/store.rs

@@ -128,10 +128,9 @@ impl PreparedProject {
     fn from_compiled(compiled: CompiledSourceProject) -> ApiResult<Self> {
         check_model_size(&compiled.decoded.project)?;
         check_source_size(&compiled.bundle)?;
-        let migration = compiled.decoded.migration.clone();
         Ok(Self {
             compiled,
-            migration,
+            migration: None,
         })
     }
 
@@ -174,10 +173,6 @@ impl PreparedProject {
         &self.compiled.bundle
     }
 
-    pub(crate) fn migration(&self) -> Option<&MigrationReport> {
-        self.migration.as_ref()
-    }
-
     pub(crate) fn source_issues(&self) -> Vec<crate::error::IssueDto> {
         self.compiled
             .diagnostics
@@ -334,12 +329,7 @@ impl Store {
             let prepared = if let Some(bundle) = envelope.source_project {
                 let prepared = PreparedProject::from_bundle(bundle.clone())
                     .map_err(|error| corrupt(error.detail))?;
-                // Explicit source upgrades may change tokens and generate new
-                // records. They must still agree with independently migrated
-                // JSON. Current-format unstabilized/inconsistent pairs reject.
-                if (prepared.bundle() != &bundle && prepared.migration.is_none())
-                    || prepared.model() != &decoded.project
-                {
+                if prepared.bundle() != &bundle || prepared.model() != &decoded.project {
                     return Err(corrupt(
                         "Stored source and model disagree, or source lacks stable identities."
                             .into(),
@@ -357,7 +347,7 @@ impl Store {
                 revision: envelope.revision,
                 model: decoded.project,
                 source_project: prepared.compiled.bundle,
-                migration: decoded.migration.or(prepared.migration),
+                migration: decoded.migration,
             };
             if stored.resource_id != filename_id || stored.revision == 0 {
                 return Err(corrupt(

crates/oa-server/tests/http.rs

@@ -8,14 +8,10 @@ use serde_json::{Value, json};
 use std::{path::Path, sync::Arc};
 use tokio::{sync::oneshot, task::JoinHandle};
 
-#[path = "http/data_contracts.rs"]
-mod data_contracts;
 #[path = "http/port_anchors.rs"]
 mod port_anchors;
 #[path = "http/source_projects.rs"]
 mod source_projects;
-#[path = "http/semantic_transitions.rs"]
-mod semantic_transitions;
 
 fn v2_missing_ports() -> Value {
     let mut old: Value = serde_json::from_slice(include_bytes!(
@@ -1933,7 +1929,7 @@ async fn legacy_json_import_and_model_reidentification_keep_the_service_address(
 }
 
 #[tokio::test]
-async fn current_migration_reports_and_invalid_typed_transaction_preserve_http_state() {
+async fn schema3_migration_reports_and_invalid_typed_transaction_preserve_http_state() {
     let directory = tempfile::tempdir().unwrap();
     let server = TestServer::start(directory.path(), None).await;
     let old = v2_missing_ports();
@@ -1949,7 +1945,7 @@ async fn current_migration_reports_and_invalid_typed_transaction_preserve_http_s
     assert_eq!(imported.status(), StatusCode::CREATED);
     let etag = imported.headers()["etag"].to_str().unwrap().to_owned();
     let summary: Value = imported.json().await.unwrap();
-    assert_eq!(summary["schema_version"], oa_core::SCHEMA_VERSION);
+    assert_eq!(summary["schema_version"], 3);
     assert_eq!(
         summary["migration"],
         serde_json::to_value(&expected.migration).unwrap()
@@ -1962,7 +1958,7 @@ async fn current_migration_reports_and_invalid_typed_transaction_preserve_http_s
     let before = std::fs::read(&filename).unwrap();
     let envelope: Value = serde_json::from_slice(&before).unwrap();
     assert!(envelope.get("migration").is_none());
-    assert_eq!(envelope["model"]["schema_version"], oa_core::SCHEMA_VERSION);
+    assert_eq!(envelope["model"]["schema_version"], 3);
     let validation = server
         .client
         .post(server.url(&format!("/projects/{id}/validation")))
@@ -2004,7 +2000,7 @@ async fn current_migration_reports_and_invalid_typed_transaction_preserve_http_s
         .text()
         .await
         .unwrap();
-    assert!(source.starts_with("arcadia 5;"));
+    assert!(source.starts_with("arcadia 3;"));
     assert_eq!(oa_core::language::parse(&source).unwrap(), stored.model);
     let no_op = server
         .client
@@ -2053,7 +2049,7 @@ async fn reopening_v2_envelope_reports_migration_without_saving_or_advancing_rev
     let migrated = server.get(id).await;
     assert_eq!(migrated.resource_id, id);
     assert_eq!(migrated.revision, 7);
-    assert_eq!(migrated.model.schema_version, oa_core::SCHEMA_VERSION);
+    assert_eq!(migrated.model.schema_version, 3);
     assert_eq!(
         migrated
             .migration
@@ -2078,7 +2074,7 @@ async fn reopening_v2_envelope_reports_migration_without_saving_or_advancing_rev
     assert_eq!(current.model.name, "Reviewed migrated model");
     let saved: Value = serde_json::from_slice(&std::fs::read(&filename).unwrap()).unwrap();
     assert_eq!(saved["revision"], 8);
-    assert_eq!(saved["model"]["schema_version"], oa_core::SCHEMA_VERSION);
+    assert_eq!(saved["model"]["schema_version"], 3);
     assert!(saved.get("migration").is_none());
     server.stop().await;
 }

crates/oa-server/tests/http/data_contracts.rs

@@ -1,734 +0,0 @@
-//! Transport evidence for the published R6 contract, not a second model fixture.
-use super::*;
-use oa_core::source_project::{ProjectLimits, SourceBundle, compile_bundle};
-use oa_core::{DataTypeDefinition, DataValue, SharedBody, TransmissionProtocol};
-use std::collections::BTreeMap;
-
-fn documented_data() -> Project {
-    let contract = include_str!("../../../../docs/language.rst");
-    let example = contract
-        .split("This complete data contract example is also exercised through the REST API:")
-        .nth(1)
-        .unwrap()
-        .split(".. code-block:: text")
-        .nth(1)
-        .unwrap();
-    let source = example
-        .lines()
-        .skip_while(|line| line.trim().is_empty())
-        .take_while(|line| line.starts_with("    ") || line.is_empty())
-        .map(|line| line.strip_prefix("    ").unwrap_or(line))
-        .collect::<Vec<_>>()
-        .join("\n");
-    let model = oa_core::language::parse(&source).unwrap();
-    oa_core::validate_candidate(&model).unwrap();
-    model
-}
-fn id(model: &Project, alias: &str) -> Id {
-    model
-        .identities()
-        .into_iter()
-        .find(|(_, a)| *a == alias)
-        .unwrap()
-        .0
-}
-fn assert_pair(stored: &StoredProject) {
-    let compiled = compile_bundle(&stored.source_project, ProjectLimits::default()).unwrap();
-    assert_eq!(compiled.decoded.project, stored.model);
-    assert_eq!(compiled.bundle, stored.source_project);
-}
-async fn commands(
-    server: &TestServer,
-    current: &StoredProject,
-    commands: Vec<Command>,
-) -> reqwest::Response {
-    server
-        .client
-        .post(server.url(&format!("/projects/{}/transactions", current.resource_id)))
-        .header("if-match", current.etag())
-        .json(&json!({"commands":commands}))
-        .send()
-        .await
-        .unwrap()
-}
-
-#[tokio::test]
-async fn published_data_contract_queries_atomic_edits_identity_and_restart() {
-    let directory = tempfile::tempdir().unwrap();
-    let server = TestServer::start(directory.path(), None).await;
-    let model = documented_data();
-    let (resource, _) = server.import(&model).await;
-    let before = server.get(resource).await;
-    assert_eq!(before.model, model);
-    assert_pair(&before);
-    for (kind, count) in [("InterfaceItemAllocation", 2), ("DataAssociation", 1)] {
-        let result: Value = server
-            .client
-            .get(server.url(&format!("/projects/{resource}/relations?kind={kind}")))
-            .send()
-            .await
-            .unwrap()
-            .error_for_status()
-            .unwrap()
-            .json()
-            .await
-            .unwrap();
-        assert_eq!(result["items"].as_array().unwrap().len(), count);
-    }
-    let voltage = id(&model, "voltage");
-    let mut invalid = model.elements[&voltage].clone();
-    let Some(SharedBody::DataType {
-        definition: DataTypeDefinition::Real { maximum, .. },
-        ..
-    }) = invalid.shared_mut()
-    else {
-        panic!()
-    };
-    *maximum = Some(12.0); // Existing default24V is outside this bound.
-    let filename = directory.path().join(format!("{resource}.json"));
-    let disk_before = std::fs::read(&filename).unwrap();
-    assert_eq!(
-        commands(
-            &server,
-            &before,
-            vec![Command::EditElement(voltage, invalid.clone())]
-        )
-        .await
-        .status(),
-        StatusCode::UNPROCESSABLE_ENTITY
-    );
-    assert_eq!(server.get(resource).await.etag(), before.etag());
-    assert_eq!(std::fs::read(&filename).unwrap(), disk_before);
-
-    let Some(SharedBody::DataType { default, .. }) = invalid.shared_mut() else {
-        panic!()
-    };
-    *default = Some(DataValue::Real(12.0));
-    let nav = id(&model, "nav_operation");
-    let other = id(&model, "monitor_operation");
-    let mut allocation = model.relations[&nav].clone();
-    let oa_core::RelationBody::InterfaceItemAllocation { transmission, .. } = &mut allocation.body
-    else {
-        panic!()
-    };
-    *transmission = TransmissionProtocol::Unicast;
-    let artifact = oa_core::ArtifactLink {
-        id: Id::new_v4(),
-        alias: "navigation_evidence".into(),
-        name: "Navigation CAD evidence".into(),
-        description: "Independent allocation evidence".into(),
-        owner: nav,
-        relation: oa_core::ArtifactRelation::Verifies,
-        uri: "cad://navigation/connector".into(),
-        revision: Some("review-17".into()),
-        fragment: Some("pin-3".into()),
-    };
-    let response = commands(
-        &server,
-        &before,
-        vec![
-            Command::EditElement(voltage, invalid),
-            Command::EditRelation(nav, allocation.clone()),
-            Command::CreateArtifact(artifact.clone()),
-        ],
-    )
-    .await;
-    assert_eq!(
-        response.status(),
-        StatusCode::OK,
-        "{}",
-        response.text().await.unwrap()
-    );
-    let changed = server.get(resource).await;
-    assert_eq!(changed.revision, before.revision + 1);
-    assert_eq!(changed.model.relations[&other], model.relations[&other]);
-    assert_eq!(changed.model.relations[&nav], allocation);
-    assert_eq!(changed.model.artifact_links[&artifact.id], artifact);
-    assert_pair(&changed);
-    assert_eq!(
-        commands(&server, &before, vec![Command::Rename(nav, "Stale".into())])
-            .await
-            .status(),
-        StatusCode::PRECONDITION_FAILED
-    );
-
-    let renamed = Id::new_v4();
-    assert_eq!(
-        commands(&server, &changed, vec![Command::Reidentify(nav, renamed)])
-            .await
-            .status(),
-        StatusCode::OK
-    );
-    let reidentified = server.get(resource).await;
-    assert_eq!(
-        reidentified.model.artifact_links[&artifact.id].owner,
-        renamed
-    );
-    // This allocation is not enforcing a live boundary, so removal is valid.
-    assert_eq!(
-        commands(&server, &reidentified, vec![Command::Delete(renamed)])
-            .await
-            .status(),
-        StatusCode::OK
-    );
-    let removed = server.get(resource).await;
-    assert!(removed.model.elements.contains_key(&id(&model, "navigate")));
-    assert_eq!(removed.model.relations[&other], model.relations[&other]);
-    assert!(!removed.model.artifact_links.contains_key(&artifact.id));
-    assert_pair(&removed);
-    let source = server
-        .client
-        .get(server.url(&format!("/projects/{resource}/source")))
-        .send()
-        .await
-        .unwrap()
-        .text()
-        .await
-        .unwrap();
-    assert!(source.starts_with("arcadia 5;"));
-    assert_eq!(oa_core::language::parse(&source).unwrap(), removed.model);
-    server.stop().await;
-    let server = TestServer::start(directory.path(), None).await;
-    let reopened = server.get(resource).await;
-    assert_eq!(reopened.model, removed.model);
-    assert_eq!(reopened.etag(), removed.etag());
-    assert_pair(&reopened);
-    server.stop().await;
-}
-
-#[tokio::test]
-async fn authored_schema3_bundle_upgrade_reports_data_defaults_and_preserves_files() {
-    let directory = tempfile::tempdir().unwrap();
-    let server = TestServer::start(directory.path(), None).await;
-    let old = SourceBundle {
-        entry: "legacy.arcadia".into(), files: BTreeMap::from([
-            ("legacy.arcadia".into(), "// Entry rationale\narcadia 3; project old_data \"Old data\" { include \"dictionary.arcadia\"; }\n".into()),
-            ("dictionary.arcadia".into(), "// Event rationale\nsa_exchange_item notification \"Notification\" { kind Event; }\n// Interface rationale\nsa_interface contract \"Contract\" { items [@notification]; }\n".into())
-        ])
-    };
-    let response = server
-        .client
-        .post(server.url("/projects/import-source-project"))
-        .json(&old)
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(response.status(), StatusCode::CREATED);
-    let summary: Value = response.json().await.unwrap();
-    let resource = summary["resource_id"].as_str().unwrap().parse().unwrap();
-    let stored = server.get(resource).await;
-    let report = stored.migration.as_ref().unwrap();
-    assert_eq!((report.from_schema, report.to_schema), (3, 5));
-    assert_eq!(report.generated_interface_allocations.len(), 1);
-    assert!(!report.semantic_defaults.is_empty());
-    let validated: Value = server
-        .client
-        .post(server.url(&format!("/projects/{resource}/validation")))
-        .json(&json!({"format":"source-project","source_project":old}))
-        .send()
-        .await
-        .unwrap()
-        .json()
-        .await
-        .unwrap();
-    assert_eq!(validated["valid"], true);
-    assert_eq!(validated["migration"]["from_schema"], 3);
-    assert_eq!(
-        validated["migration"]["generated_interface_allocations"]
-            .as_array()
-            .unwrap()
-            .len(),
-        1
-    );
-    assert_eq!(stored.source_project.files.len(), 2);
-    assert!(stored.source_project.files["legacy.arcadia"].contains("arcadia 5;"));
-    for text in [
-        "// Event rationale",
-        "// Interface rationale",
-        "interface_item_allocation",
-    ] {
-        assert!(stored.source_project.files["dictionary.arcadia"].contains(text));
-    }
-    assert_pair(&stored);
-    let filename = directory.path().join(format!("{resource}.json"));
-    let bytes = std::fs::read(&filename).unwrap();
-    server.stop().await;
-    let server = TestServer::start(directory.path(), None).await;
-    let reopened = server.get(resource).await;
-    assert_eq!(reopened.model, stored.model);
-    assert_eq!(reopened.source_project, stored.source_project);
-    assert!(reopened.migration.is_none());
-    assert_eq!(std::fs::read(filename).unwrap(), bytes);
-    server.stop().await;
-}
-
-#[tokio::test]
-async fn existing_schema3_coupled_envelope_upgrades_in_memory_until_explicit_save() {
-    let directory = tempfile::tempdir().unwrap();
-    let resource = Id::new_v4();
-    let filename = directory.path().join(format!("{resource}.json"));
-    let old_model: Value = serde_json::from_str(include_str!(
-        "../../../oa-core/tests/fixtures/v3-data-contract.json"
-    ))
-    .unwrap();
-    let old_bundle = SourceBundle {
-        entry: "project.arcadia".into(),
-        files: BTreeMap::from([(
-            "project.arcadia".into(),
-            include_str!("../../../oa-core/tests/fixtures/v3-data-contract.arcadia").into(),
-        )]),
-    };
-    let original = serde_json::to_vec(&json!({"resource_id":resource,"revision":17,"model":old_model,"source_project":old_bundle})).unwrap();
-    std::fs::write(&filename, &original).unwrap();
-    let server = TestServer::start(directory.path(), None).await;
-    let opened = server.get(resource).await;
-    assert_eq!(opened.revision, 17);
-    assert_eq!(opened.model.schema_version, 5);
-    assert_eq!(opened.migration.as_ref().unwrap().from_schema, 3);
-    assert!(opened.source_project.files["project.arcadia"].contains("arcadia 5;"));
-    assert_pair(&opened);
-    assert_eq!(std::fs::read(&filename).unwrap(), original);
-    assert_eq!(
-        commands(
-            &server,
-            &opened,
-            vec![Command::Rename(
-                opened.model.id,
-                "Reviewed data migration".into()
-            )]
-        )
-        .await
-        .status(),
-        StatusCode::OK
-    );
-    let saved = server.get(resource).await;
-    assert_eq!(saved.revision, 18);
-    let bytes = std::fs::read(&filename).unwrap();
-    assert_ne!(bytes, original);
-    server.stop().await;
-    let server = TestServer::start(directory.path(), None).await;
-    let reopened = server.get(resource).await;
-    assert_eq!(reopened.model, saved.model);
-    assert_eq!(reopened.source_project, saved.source_project);
-    assert_eq!(reopened.etag(), saved.etag());
-    assert!(reopened.migration.is_none());
-    assert_eq!(std::fs::read(&filename).unwrap(), bytes);
-    server.stop().await;
-}
-
-#[tokio::test]
-async fn qualified_call_reply_values_reject_invalid_edits_and_survive_identity_source_and_restart()
-{
-    use oa_core::{
-        Element, FieldStorage, MessageKind, MessageValue, OccurrenceBody, ParameterDirection,
-        PortContract, RelationBody, ScenarioViewpoint, TypeRef,
-    };
-    fn values(model: &Project, occurrence: Id) -> &[MessageValue] {
-        let Some(SharedBody::Occurrence {
-            body: OccurrenceBody::Exchange { values, .. },
-            ..
-        }) = model.elements[&occurrence].shared()
-        else {
-            panic!("Expected message");
-        };
-        values
-    }
-    fn edited_values(model: &Project, occurrence: Id, next: Vec<MessageValue>) -> Element {
-        let mut element = model.elements[&occurrence].clone();
-        let Some(SharedBody::Occurrence {
-            body: OccurrenceBody::Exchange { values, .. },
-            ..
-        }) = element.shared_mut()
-        else {
-            panic!("Expected message");
-        };
-        *values = next;
-        element
-    }
-    let mut model = documented_data();
-    let operation = id(&model, "navigate");
-    let coordinate = id(&model, "coordinate");
-    let located = id(&model, "located");
-    let latitude = id(&model, "latitude");
-    let origin = id(&model, "origin");
-    let destination = id(&model, "destination");
-    let accepted = id(&model, "accepted");
-    // The second parameter inherits the very same latitude identity.
-    let Some(SharedBody::DataField { type_ref, .. }) =
-        model.elements.get_mut(&destination).unwrap().shared_mut()
-    else {
-        panic!();
-    };
-    *type_ref = TypeRef::Named(located);
-    let next = model
-        .add_element(
-            Kind::DataField,
-            Layer::Sa,
-            "Next coordinate",
-            Some(coordinate),
-        )
-        .unwrap();
-    *model.elements.get_mut(&next).unwrap().shared_mut().unwrap() = SharedBody::DataField {
-        type_ref: TypeRef::Named(coordinate),
-        minimum: 0,
-        maximum: Some(1),
-        direction: ParameterDirection::Unspecified,
-        storage: FieldStorage::Value,
-        unit: String::new(),
-        default: None,
-    };
-    let requester = model
-        .add_element(Kind::Function, Layer::Sa, "Request navigation", None)
-        .unwrap();
-    let provider = model
-        .add_element(Kind::Function, Layer::Sa, "Provide navigation", None)
-        .unwrap();
-    let output = Id::new_v4();
-    let input = Id::new_v4();
-    for (port, contract) in [
-        (
-            output,
-            PortContract::FunctionOutput {
-                outgoing_items: vec![operation],
-            },
-        ),
-        (
-            input,
-            PortContract::FunctionInput {
-                incoming_items: vec![operation],
-            },
-        ),
-    ] {
-        let (owner, name) = if port == output {
-            (requester, "Navigation output")
-        } else {
-            (provider, "Navigation input")
-        };
-        let element = oa_core::ports::make_port(&model, port, owner, name, contract).unwrap();
-        model.elements.insert(port, element);
-    }
-    let exchange = model.relate(
-        RelationKind::FunctionalExchange,
-        "Navigation request",
-        requester,
-        provider,
-    );
-    model.relations.get_mut(&exchange).unwrap().body = RelationBody::FunctionalExchange {
-        source: requester,
-        target: provider,
-        source_port: output,
-        target_port: input,
-        items: vec![operation],
-    };
-    let scenario = model
-        .add_element(Kind::Scenario, Layer::Sa, "Navigation conversation", None)
-        .unwrap();
-    let Some(SharedBody::Scenario { viewpoint, .. }) =
-        model.elements.get_mut(&scenario).unwrap().shared_mut()
-    else {
-        panic!();
-    };
-    *viewpoint = ScenarioViewpoint::Functional;
-    let sender = model
-        .add_element(Kind::Lifeline, Layer::Sa, "Requester line", Some(scenario))
-        .unwrap();
-    let receiver = model
-        .add_element(Kind::Lifeline, Layer::Sa, "Provider line", Some(scenario))
-        .unwrap();
-    for (line, represented) in [(sender, requester), (receiver, provider)] {
-        *model.elements.get_mut(&line).unwrap().shared_mut().unwrap() = SharedBody::Lifeline {
-            represented: Some(represented),
-        };
-    }
-    let call = model
-        .add_element(
-            Kind::Occurrence,
-            Layer::Sa,
-            "Navigation call",
-            Some(scenario),
-        )
-        .unwrap();
-    let reply = model
-        .add_element(
-            Kind::Occurrence,
-            Layer::Sa,
-            "Navigation reply",
-            Some(scenario),
-        )
-        .unwrap();
-    for (occurrence, message_kind, from, to, reply_to) in [
-        (call, MessageKind::Call, sender, receiver, None),
-        (reply, MessageKind::Reply, receiver, sender, Some(call)),
-    ] {
-        *model
-            .elements
-            .get_mut(&occurrence)
-            .unwrap()
-            .shared_mut()
-            .unwrap() = SharedBody::Occurrence {
-            body: OccurrenceBody::Exchange {
-                exchange: Some(exchange),
-                sender: Some(from),
-                receiver: Some(to),
-                message_kind,
-                reply_to,
-                values: vec![],
-            },
-            precondition: String::new(),
-            postcondition: String::new(),
-        };
-    }
-    model
-        .elements
-        .get_mut(&scenario)
-        .unwrap()
-        .steps_mut()
-        .unwrap()
-        .extend([call, reply]);
-    oa_core::validate_candidate(&model).unwrap();
-
-    let directory = tempfile::tempdir().unwrap();
-    let server = TestServer::start(directory.path(), None).await;
-    let (resource, _) = server.import(&model).await;
-    let before = server.get(resource).await;
-    let call_values = vec![
-        MessageValue {
-            path: vec![origin],
-            field: latitude,
-            expression: "  origin.latitude\n+ 0.25  ".into(),
-        },
-        MessageValue {
-            path: vec![destination],
-            field: latitude,
-            expression: "destination.latitude".into(),
-        },
-        MessageValue {
-            path: vec![origin, next],
-            field: latitude,
-            expression: "previous.latitude".into(),
-        },
-    ];
-    let reply_values = vec![MessageValue {
-        path: vec![],
-        field: accepted,
-        expression: "true".into(),
-    }];
-    let response = commands(
-        &server,
-        &before,
-        vec![
-            Command::EditElement(call, edited_values(&model, call, call_values.clone())),
-            Command::EditElement(reply, edited_values(&model, reply, reply_values.clone())),
-        ],
-    )
-    .await;
-    assert_eq!(
-        response.status(),
-        StatusCode::OK,
-        "{}",
-        response.text().await.unwrap()
-    );
-    let authored = server.get(resource).await;
-    assert_eq!(authored.revision, before.revision + 1);
-    assert_eq!(values(&authored.model, call), call_values);
-    assert_eq!(values(&authored.model, reply), reply_values);
-    assert_eq!(
-        authored.model.elements[&latitude],
-        model.elements[&latitude]
-    );
-    assert_pair(&authored);
-    let filename = directory.path().join(format!("{resource}.json"));
-    let bytes = std::fs::read(&filename).unwrap();
-    for (occurrence, value, code) in [
-        (
-            call,
-            MessageValue {
-                path: vec![],
-                field: accepted,
-                expression: "wrong call phase".into(),
-            },
-            "message_parameter_phase",
-        ),
-        (
-            reply,
-            MessageValue {
-                path: vec![origin],
-                field: latitude,
-                expression: "wrong reply phase".into(),
-            },
-            "message_parameter_phase",
-        ),
-        (
-            call,
-            MessageValue {
-                path: vec![origin, accepted],
-                field: latitude,
-                expression: "unrelated hop".into(),
-            },
-            "message_value_field",
-        ),
-    ] {
-        let invalid = edited_values(&authored.model, occurrence, vec![value]);
-        let mut invalid_model = authored.model.clone();
-        invalid_model.elements.insert(occurrence, invalid.clone());
-        let response = commands(
-            &server,
-            &authored,
-            vec![Command::EditElement(occurrence, invalid)],
-        )
-        .await;
-        assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
-        let problem: Value = response.json().await.unwrap();
-        assert_eq!(problem["code"], "command_rejected", "{problem}");
-        assert!(
-            problem["detail"].as_str().unwrap().starts_with(code),
-            "{problem}"
-        );
-        // Transactions report the first rejection; validation supplies located issues.
-        let validation: Value = server
-            .client
-            .post(server.url(&format!("/projects/{resource}/validation")))
-            .json(&json!({"format":"json", "model":invalid_model}))
-            .send()
-            .await
-            .unwrap()
-            .error_for_status()
-            .unwrap()
-            .json()
-            .await
-            .unwrap();
-        assert_eq!(validation["valid"], false);
-        assert!(
-            validation["issues"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .any(|issue| issue["code"] == code
-                    && issue["object_id"] == json!(occurrence)
-                    && issue["field"] == "values.path"),
-            "{problem}"
-        );
-        let unchanged = server.get(resource).await;
-        assert_eq!(unchanged.etag(), authored.etag());
-        assert_eq!(unchanged.model, authored.model);
-        assert_eq!(unchanged.source_project, authored.source_project);
-        assert_eq!(std::fs::read(&filename).unwrap(), bytes);
-    }
-
-    // Source transport changes one argument without conflating the shared leaf.
-    let source = server
-        .client
-        .get(server.url(&format!("/projects/{resource}/source")))
-        .send()
-        .await
-        .unwrap()
-        .error_for_status()
-        .unwrap()
-        .text()
-        .await
-        .unwrap();
-    let edited_source = source.replace(
-        "\"destination.latitude\"",
-        "\"destination.corrected_latitude\"",
-    );
-    assert_ne!(edited_source, source);
-    let response = server
-        .client
-        .put(server.url(&format!("/projects/{resource}/source")))
-        .header("if-match", authored.etag())
-        .header("content-type", "text/plain")
-        .body(edited_source)
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(
-        response.status(),
-        StatusCode::OK,
-        "{}",
-        response.text().await.unwrap()
-    );
-    let source_edited = server.get(resource).await;
-    assert_eq!(source_edited.revision, authored.revision + 1);
-    let mut expected_call = call_values.clone();
-    expected_call[1].expression = "destination.corrected_latitude".into();
-    assert_eq!(values(&source_edited.model, call), expected_call);
-    assert_eq!(values(&source_edited.model, reply), reply_values);
-    assert_pair(&source_edited);
-
-    // Reidentify every kind of enclosing hop, the shared terminal, and its base type.
-    let mapping = [origin, destination, next, latitude, coordinate]
-        .into_iter()
-        .map(|old| (old, Id::new_v4()))
-        .collect::<BTreeMap<_, _>>();
-    let response = commands(
-        &server,
-        &source_edited,
-        mapping
-            .iter()
-            .map(|(old, new)| Command::Reidentify(*old, *new))
-            .collect(),
-    )
-    .await;
-    assert_eq!(
-        response.status(),
-        StatusCode::OK,
-        "{}",
-        response.text().await.unwrap()
-    );
-    let changed = server.get(resource).await;
-    assert_eq!(changed.revision, source_edited.revision + 1);
-    for value in &mut expected_call {
-        value.path = value.path.iter().map(|hop| mapping[hop]).collect();
-        value.field = mapping[&value.field];
-    }
-    assert_eq!(values(&changed.model, call), expected_call);
-    assert_eq!(values(&changed.model, reply), reply_values);
-    assert_eq!(
-        changed.model.elements[&mapping[&latitude]].parent,
-        Some(mapping[&coordinate])
-    );
-    assert!(
-        matches!(changed.model.elements[&located].shared(), Some(SharedBody::DataType {
-        definition: DataTypeDefinition::Record { supertype: Some(base) }, ..
-    }) if *base == mapping[&coordinate])
-    );
-    assert!(
-        oa_core::data::effective_fields(&changed.model, located)
-            .iter()
-            .any(|field| field.id == mapping[&latitude])
-    );
-    for old in mapping.keys() {
-        assert!(!changed.model.contains(*old));
-    }
-    assert!(
-        matches!(changed.model.elements[&reply].shared(), Some(SharedBody::Occurrence {
-        body: OccurrenceBody::Exchange { reply_to: Some(correlation), .. }, ..
-    }) if *correlation == call)
-    );
-    assert_pair(&changed);
-    let source = server
-        .client
-        .get(server.url(&format!("/projects/{resource}/source")))
-        .send()
-        .await
-        .unwrap()
-        .error_for_status()
-        .unwrap()
-        .text()
-        .await
-        .unwrap();
-    assert!(source.starts_with("arcadia 5;"));
-    assert_eq!(oa_core::language::parse(&source).unwrap(), changed.model);
-    let saved = std::fs::read(&filename).unwrap();
-    server.stop().await;
-    let server = TestServer::start(directory.path(), None).await;
-    let reopened = server.get(resource).await;
-    assert_eq!(reopened.etag(), changed.etag());
-    assert_eq!(reopened.model, changed.model);
-    assert_eq!(reopened.source_project, changed.source_project);
-    assert_eq!(values(&reopened.model, call), expected_call);
-    assert_eq!(values(&reopened.model, reply), reply_values);
-    assert_pair(&reopened);
-    assert_eq!(std::fs::read(&filename).unwrap(), saved);
-    server.stop().await;
-}

crates/oa-server/tests/http/semantic_transitions.rs

@@ -1,675 +0,0 @@
-use super::*;
-use oa_core::{semantic::*, transitions::*, *};
-
-fn fixture() -> Project {
-    oa_core::persistence::decode(include_bytes!(
-        "../../../oa-core/tests/fixtures/v4-reviewed-prose.json"
-    ))
-    .unwrap()
-}
-fn key(n: u128) -> Id {
-    Id::from_u128(0x40000000_0000_4000_8000_000000000000 + n)
-}
-fn request(
-    source: Id,
-    target: Id,
-    decisions: Vec<(FacetSelector, SemanticDecision)>,
-) -> SemanticTransitionRequest {
-    let direction = if source == key(3) {
-        TransitionDirection::SaToOa
-    } else {
-        TransitionDirection::OaToSa
-    };
-    let mut transition = TransitionRequest::new(direction, vec![source]);
-    transition.mappings.push(TransitionMapping {
-        source,
-        target: Some(target),
-        target_kind: None,
-    });
-    let mut request = SemanticTransitionRequest::new(transition);
-    request.reviews.push(SemanticReviewRequest {
-        source,
-        resolutions: decisions
-            .into_iter()
-            .map(|(facet, decision)| FacetResolution { facet, decision })
-            .collect(),
-        reset: vec![],
-    });
-    request
-}
-async fn post(
-    server: &TestServer,
-    id: Id,
-    operation: &str,
-    etag: Option<&str>,
-    value: &impl serde::Serialize,
-) -> reqwest::Response {
-    let mut call = server
-        .client
-        .post(server.url(&format!("/projects/{id}/semantic-transitions/{operation}")))
-        .json(value);
-    if let Some(etag) = etag {
-        call = call.header("if-match", etag);
-    }
-    call.send().await.unwrap()
-}
-async fn ok(response: reqwest::Response) -> Value {
-    let status = response.status();
-    let value = response.json().await.unwrap();
-    assert_eq!(status, StatusCode::OK, "{value}");
-    value
-}
-async fn preview(
-    server: &TestServer,
-    stored: &StoredProject,
-    request: &SemanticTransitionRequest,
-) -> Value {
-    ok(post(
-        server,
-        stored.resource_id,
-        "preview",
-        Some(&stored.etag()),
-        request,
-    )
-    .await)
-    .await
-}
-fn assert_pair(stored: &StoredProject) {
-    assert_eq!(
-        oa_core::source_project::compile_bundle(&stored.source_project, Default::default())
-            .unwrap()
-            .decoded
-            .project,
-        stored.model
-    );
-}
-
-#[tokio::test]
-async fn semantic_partial_review_query_source_and_restart_share_one_revision() {
-    let directory = tempfile::tempdir().unwrap();
-    let server = TestServer::start(directory.path(), None).await;
-    let (id, _) = server.import(&fixture()).await;
-    let mut stored = server.get(id).await;
-    let mut bundle = stored.source_project.clone();
-    bundle
-        .files
-        .get_mut(&bundle.entry)
-        .unwrap()
-        .insert_str(0, "// Authored review rationale\n");
-    let changed = server
-        .client
-        .put(server.url(&format!("/projects/{id}/source-project")))
-        .header("if-match", stored.etag())
-        .json(&bundle)
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(changed.status(), StatusCode::OK);
-    stored = server.get(id).await;
-    let disk_path = directory.path().join(format!("{id}.json"));
-    let before_bytes = std::fs::read(&disk_path).unwrap();
-    let query = json!({"traces":[key(4)],"references":{},"revision":stored.revision});
-    let queried = ok(post(&server, id, "query", None, &query).await).await;
-    assert_eq!(queried["items"][0]["drift"]["own"], "Unreviewed");
-    let req = request(
-        key(2),
-        key(3),
-        vec![
-            (
-                FacetSelector::Data(DataFacet::Unit),
-                SemanticDecision::KeepTarget,
-            ),
-            (
-                FacetSelector::Header(HeaderFacet::Name),
-                SemanticDecision::TakeSource,
-            ),
-        ],
-    );
-    let plan = preview(&server, &stored, &req).await;
-    assert_eq!(plan["plan"]["conflicts"], json!([]));
-    assert_eq!(
-        plan["plan"]["reviews"][0]["acknowledged"]
-            .as_array()
-            .unwrap()
-            .len(),
-        2
-    );
-    assert_eq!(std::fs::read(&disk_path).unwrap(), before_bytes);
-    assert_eq!(server.get(id).await.etag(), stored.etag());
-    let applied = ok(post(&server, id, "apply", Some(&stored.etag()), &plan).await).await;
-    assert_eq!(applied["revision"], stored.revision + 1);
-    let committed = server.get(id).await;
-    assert_pair(&committed);
-    assert!(
-        committed.source_project.files[&committed.source_project.entry]
-            .contains("// Authored review rationale")
-    );
-    assert_eq!(committed.model.elements[&key(3)].name, "OA dimension now");
-    assert!(
-        matches!(committed.model.elements[&key(3)].shared(), Some(SharedBody::DataType { unit, definition: DataTypeDefinition::Real { .. }, .. }) if unit == "ft")
-    );
-    let queried = ok(post(&server, id, "query", None, &json!({"traces":[key(4)]})).await).await;
-    let facts: Vec<FacetDrift> =
-        serde_json::from_value(queried["items"][0]["facets"].clone()).unwrap();
-    assert_eq!(
-        facts
-            .iter()
-            .find(|f| f.selector == FacetSelector::Data(DataFacet::Unit))
-            .unwrap()
-            .drift,
-        Drift::Unchanged
-    );
-    assert_eq!(
-        facts
-            .iter()
-            .find(|f| f.selector == FacetSelector::Data(DataFacet::Constructor))
-            .unwrap()
-            .drift,
-        Drift::Unreviewed
-    );
-    assert!(
-        queried["items"][0]["drift"]["own_unreviewed"]
-            .as_bool()
-            .unwrap()
-    );
-    let repeat = preview(&server, &committed, &req).await;
-    let reapplied = ok(post(&server, id, "apply", Some(&committed.etag()), &repeat).await).await;
-    assert_eq!(reapplied["changed"], false);
-    assert_eq!(reapplied["revision"], committed.revision);
-    server.stop().await;
-    let server = TestServer::start(directory.path(), None).await;
-    let reopened = server.get(id).await;
-    assert_eq!(reopened.model, committed.model);
-    assert_eq!(reopened.source_project, committed.source_project);
-    assert_eq!(reopened.etag(), committed.etag());
-    server.stop().await;
-}
-
-#[tokio::test]
-async fn semantic_strict_rejection_stale_plans_and_source_only_changes_never_write() {
-    let directory = tempfile::tempdir().unwrap();
-    let server = TestServer::start(directory.path(), None).await;
-    let (id, etag) = server.import(&fixture()).await;
-    let stored = server.get(id).await;
-    let disk_path = directory.path().join(format!("{id}.json"));
-    let before = std::fs::read(&disk_path).unwrap();
-    let req = request(
-        key(2),
-        key(3),
-        vec![(
-            FacetSelector::Data(DataFacet::Unit),
-            SemanticDecision::TakeSource,
-        )],
-    );
-    let plan = preview(&server, &stored, &req).await;
-    for operation in ["preview", "apply"] {
-        let body = if operation == "preview" {
-            serde_json::to_value(&req).unwrap()
-        } else {
-            plan.clone()
-        };
-        assert_eq!(
-            post(&server, id, operation, None, &body).await.status(),
-            StatusCode::PRECONDITION_REQUIRED
-        );
-    }
-    let mut malformed = serde_json::to_value(&req).unwrap();
-    malformed["reviews"][0]["resolutions"][0]["facet"] = json!({"Data":"arbitrary_path"});
-    assert_eq!(
-        post(&server, id, "preview", Some(&etag), &malformed)
-            .await
-            .status(),
-        StatusCode::BAD_REQUEST
-    );
-    malformed = serde_json::to_value(&req).unwrap();
-    malformed["unexpected"] = true.into();
-    assert_eq!(
-        post(&server, id, "preview", Some(&etag), &malformed)
-            .await
-            .status(),
-        StatusCode::BAD_REQUEST
-    );
-    for (query, expected) in [
-        (json!({"traces":[]}), StatusCode::BAD_REQUEST),
-        (json!({"traces":[key(4),key(4)]}), StatusCode::BAD_REQUEST),
-        (json!({"traces":[key(99)]}), StatusCode::NOT_FOUND),
-        (
-            json!({"traces":[key(4)],"revision":99}),
-            StatusCode::CONFLICT,
-        ),
-    ] {
-        assert_eq!(
-            post(&server, id, "query", None, &query).await.status(),
-            expected
-        );
-    }
-    for mutation in [
-        "commands",
-        "base_fingerprint",
-        "prepared_fingerprint",
-        "base_revision",
-    ] {
-        let mut rejected = plan.clone();
-        let expected = if mutation == "base_revision" {
-            rejected[mutation] = 99.into();
-            StatusCode::PRECONDITION_FAILED
-        } else {
-            rejected["plan"][mutation] = if mutation == "commands" {
-                json!([])
-            } else {
-                json!("altered")
-            };
-            StatusCode::UNPROCESSABLE_ENTITY
-        };
-        assert_eq!(
-            post(&server, id, "apply", Some(&etag), &rejected)
-                .await
-                .status(),
-            expected
-        );
-    }
-    let mut duplicate = req.clone();
-    let repeated = duplicate.reviews[0].resolutions[0].clone();
-    duplicate.reviews[0].resolutions.push(repeated);
-    let conflicted = preview(&server, &stored, &duplicate).await;
-    assert!(
-        !conflicted["plan"]["conflicts"]
-            .as_array()
-            .unwrap()
-            .is_empty()
-    );
-    assert_eq!(
-        post(&server, id, "apply", Some(&etag), &conflicted)
-            .await
-            .status(),
-        StatusCode::UNPROCESSABLE_ENTITY
-    );
-    assert_eq!(std::fs::read(&disk_path).unwrap(), before);
-    assert_eq!(server.get(id).await.etag(), etag);
-    let mut bundle = stored.source_project.clone();
-    bundle
-        .files
-        .get_mut(&bundle.entry)
-        .unwrap()
-        .push_str("\n// Source-only concurrent edit\n");
-    let changed = server
-        .client
-        .put(server.url(&format!("/projects/{id}/source-project")))
-        .header("if-match", &etag)
-        .json(&bundle)
-        .send()
-        .await
-        .unwrap();
-    assert_eq!(changed.status(), StatusCode::OK);
-    let current = server.get(id).await;
-    assert_eq!(current.model, stored.model);
-    let bytes = std::fs::read(&disk_path).unwrap();
-    for precondition in [&etag, &current.etag()] {
-        assert_eq!(
-            post(&server, id, "apply", Some(precondition), &plan)
-                .await
-                .status(),
-            StatusCode::PRECONDITION_FAILED
-        );
-    }
-    assert_eq!(std::fs::read(&disk_path).unwrap(), bytes);
-    server.stop().await;
-}
-
-#[tokio::test]
-async fn semantic_candidate_constructor_reverse_direction_and_explicit_trace_selection() {
-    let directory = tempfile::tempdir().unwrap();
-    let server = TestServer::start(directory.path(), None).await;
-    let mut model = fixture();
-    let mut second = model.traces[&key(4)].clone();
-    second.id = key(5);
-    second.alias = "second_review".into();
-    second.kind = TraceKind::Manual;
-    model.traces.insert(second.id, second);
-    let (id, _) = server.import(&model).await;
-    let stored = server.get(id).await;
-    let mut req = request(
-        key(3),
-        key(2),
-        vec![
-            (
-                FacetSelector::Data(DataFacet::Constructor),
-                SemanticDecision::TakeSource,
-            ),
-            (
-                FacetSelector::Data(DataFacet::Unit),
-                SemanticDecision::Candidate,
-            ),
-        ],
-    );
-    let ambiguous = preview(&server, &stored, &req).await;
-    assert!(
-        !ambiguous["plan"]["conflicts"]
-            .as_array()
-            .unwrap()
-            .is_empty()
-    );
-    req.traces.insert(key(3), key(5));
-    let mut candidate = model.elements[&key(2)].clone();
-    *candidate.shared_mut().unwrap() = model.elements[&key(3)].shared().unwrap().clone();
-    if let SharedBody::DataType { unit, .. } = candidate.shared_mut().unwrap() {
-        *unit = "cm".into();
-    }
-    req.candidates
-        .push(SemanticRecord::Element(candidate.clone()));
-    req.references.insert(key(900), key(901)); // Historical correspondence survives transport unchanged.
-    let envelope = preview(&server, &stored, &req).await;
-    assert_eq!(
-        envelope["plan"]["request"],
-        serde_json::to_value(&req).unwrap()
-    );
-    assert_eq!(envelope["plan"]["conflicts"], json!([]));
-    ok(post(&server, id, "apply", Some(&stored.etag()), &envelope).await).await;
-    let applied = server.get(id).await;
-    assert_eq!(applied.model.elements[&key(2)], candidate);
-    assert!(
-        applied.model.traces[&key(4)]
-            .baseline
-            .as_ref()
-            .unwrap()
-            .semantic
-            .is_none()
-    );
-    assert!(
-        applied.model.traces[&key(5)]
-            .baseline
-            .as_ref()
-            .unwrap()
-            .semantic
-            .is_some()
-    );
-    assert_pair(&applied);
-    server.stop().await;
-}
-
-#[tokio::test]
-async fn semantic_new_mapping_keeps_preview_generated_identifiers() {
-    let directory = tempfile::tempdir().unwrap();
-    let server = TestServer::start(directory.path(), None).await;
-    let mut model = Project::empty();
-    let source = model
-        .add_element(Kind::Activity, Layer::Oa, "Inspect", None)
-        .unwrap();
-    let (id, _) = server.import(&model).await;
-    let stored = server.get(id).await;
-    let req = SemanticTransitionRequest::new(TransitionRequest::new(
-        TransitionDirection::OaToSa,
-        vec![source],
-    ));
-    let envelope = preview(&server, &stored, &req).await;
-    assert_eq!(envelope["plan"]["conflicts"], json!([]));
-    let plan: SemanticTransitionPlan = serde_json::from_value(envelope["plan"].clone()).unwrap();
-    let expected = oa_core::semantic::apply_semantic_transition(&model, &plan).unwrap();
-    ok(post(&server, id, "apply", Some(&stored.etag()), &envelope).await).await;
-    assert_eq!(server.get(id).await.model, expected);
-    server.stop().await;
-}
-
-#[tokio::test]
-async fn semantic_resets_and_invalid_candidates_preserve_deliberate_review_boundaries() {
-    let directory = tempfile::tempdir().unwrap();
-    let server = TestServer::start(directory.path(), None).await;
-    let model = fixture();
-    let reviewed = oa_core::semantic::plan_semantic_transition(
-        &model,
-        request(
-            key(2),
-            key(3),
-            vec![
-                (
-                    FacetSelector::Data(DataFacet::Unit),
-                    SemanticDecision::KeepTarget,
-                ),
-                (
-                    FacetSelector::Header(HeaderFacet::Name),
-                    SemanticDecision::KeepTarget,
-                ),
-            ],
-        ),
-    )
-    .unwrap();
-    let model = oa_core::semantic::apply_semantic_transition(&model, &reviewed).unwrap();
-    let (id, _) = server.import(&model).await;
-    let stored = server.get(id).await;
-    let before = std::fs::read(directory.path().join(format!("{id}.json"))).unwrap();
-    let mut req = request(
-        key(2),
-        key(3),
-        vec![(
-            FacetSelector::Data(DataFacet::Unit),
-            SemanticDecision::Candidate,
-        )],
-    );
-    let mut candidate = model.elements[&key(3)].clone();
-    candidate.name = "Unselected incidental edit".into();
-    req.candidates.push(SemanticRecord::Element(candidate));
-    let invalid = preview(&server, &stored, &req).await;
-    assert!(!invalid["plan"]["conflicts"].as_array().unwrap().is_empty());
-    assert_eq!(
-        post(&server, id, "apply", Some(&stored.etag()), &invalid)
-            .await
-            .status(),
-        StatusCode::UNPROCESSABLE_ENTITY
-    );
-    assert_eq!(
-        std::fs::read(directory.path().join(format!("{id}.json"))).unwrap(),
-        before
-    );
-    req = request(key(2), key(3), vec![]);
-    req.reviews[0]
-        .reset
-        .push(FacetSelector::Data(DataFacet::Unit));
-    let reset = preview(&server, &stored, &req).await;
-    assert_eq!(
-        reset["plan"]["request"]["reviews"][0]["reset"],
-        json!([{"Data":"Unit"}])
-    );
-    assert_eq!(reset["plan"]["conflicts"], json!([]));
-    ok(post(&server, id, "apply", Some(&stored.etag()), &reset).await).await;
-    let current = server.get(id).await;
-    let facts = &current.model.traces[&key(4)]
-        .baseline
-        .as_ref()
-        .unwrap()
-        .semantic
-        .as_ref()
-        .unwrap()
-        .facets;
-    assert_eq!(facts.len(), 1);
-    assert_eq!(
-        facts[0].selector(),
-        FacetSelector::Header(HeaderFacet::Name)
-    );
-    assert_eq!(current.model.elements, model.elements);
-    assert_pair(&current);
-    server.stop().await;
-}
-
-fn cleanup_fixture() -> (Project, Id, Id, Id) {
-    let mut p = Project::empty();
-    let oa = p
-        .add_element(Kind::DataType, Layer::Oa, "Source record", None)
-        .unwrap();
-    let sa = p
-        .add_element(Kind::DataType, Layer::Sa, "Target record", None)
-        .unwrap();
-    let base = p
-        .add_element(Kind::DataType, Layer::Sa, "Base record", None)
-        .unwrap();
-    for (id, supertype) in [(oa, None), (base, None), (sa, Some(base))] {
-        *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::DataType {
-            definition: DataTypeDefinition::Record { supertype },
-            default: None,
-            unit: String::new(),
-        };
-    }
-    let leaf = p
-        .add_element(Kind::DataField, Layer::Sa, "Coordinate", Some(base))
-        .unwrap();
-    let item = p
-        .add_element(Kind::ExchangeItem, Layer::Sa, "Location", None)
-        .unwrap();
-    let field = p
-        .add_element(Kind::DataField, Layer::Sa, "Payload", Some(item))
-        .unwrap();
-    for (id, type_ref) in [(leaf, TypeRef::Real), (field, TypeRef::Named(sa))] {
-        *p.elements.get_mut(&id).unwrap().shared_mut().unwrap() = SharedBody::DataField {
-            type_ref,
-            minimum: 0,
-            maximum: Some(1),
-            unit: String::new(),
-            direction: ParameterDirection::Unspecified,
-            storage: FieldStorage::Value,
-            default: None,
-        };
-    }
-    let sender = p
-        .add_element(Kind::Function, Layer::Sa, "Send", None)
-        .unwrap();
-    let receiver = p
-        .add_element(Kind::Function, Layer::Sa, "Receive", None)
-        .unwrap();
-    let exchange = p.relate(
-        RelationKind::FunctionalExchange,
-        "Location report",
-        sender,
-        receiver,
-    );
-    let RelationBody::FunctionalExchange {
-        items,
-        source_port,
-        target_port,
-        ..
-    } = &mut p.relations.get_mut(&exchange).unwrap().body
-    else {
-        panic!()
-    };
-    items.push(item);
-    for id in [*source_port, *target_port] {
-        match p.elements.get_mut(&id).unwrap().shared_mut().unwrap() {
-            SharedBody::Port {
-                contract: PortContract::FunctionInput { incoming_items },
-                ..
-            } => incoming_items.push(item),
-            SharedBody::Port {
-                contract: PortContract::FunctionOutput { outgoing_items },
-                ..
-            } => outgoing_items.push(item),
-            _ => panic!(),
-        }
-    }
-    let scenario = p
-        .add_element(Kind::Scenario, Layer::Sa, "Report location", None)
-        .unwrap();
-    let message = p
-        .add_element(Kind::Occurrence, Layer::Sa, "Report", Some(scenario))
-        .unwrap();
-    *p.elements.get_mut(&message).unwrap().shared_mut().unwrap() = SharedBody::Occurrence {
-        body: OccurrenceBody::Exchange {
-            exchange: Some(exchange),
-            sender: None,
-            receiver: None,
-            message_kind: MessageKind::Asynchronous,
-            reply_to: None,
-            values: vec![MessageValue {
-                path: vec![field],
-                field: leaf,
-                expression: "10".into(),
-            }],
-        },
-        precondition: String::new(),
-        postcondition: String::new(),
-    };
-    p.elements
-        .get_mut(&scenario)
-        .unwrap()
-        .steps_mut()
-        .unwrap()
-        .push(message);
-    let trace = Id::new_v4();
-    p.traces.insert(
-        trace,
-        Trace {
-            id: trace,
-            alias: "record_trace".into(),
-            name: "Record correspondence".into(),
-            description: String::new(),
-            oa,
-            sa,
-            kind: TraceKind::Manual,
-            baseline: None,
-        },
-    );
-    (p, oa, sa, message)
-}
-
-#[tokio::test]
-async fn semantic_cleanup_impacts_require_exact_acceptance_before_atomic_apply() {
-    let directory = tempfile::tempdir().unwrap();
-    let server = TestServer::start(directory.path(), None).await;
-    let (model, oa, sa, message) = cleanup_fixture();
-    let (id, _) = server.import(&model).await;
-    let stored = server.get(id).await;
-    let path = directory.path().join(format!("{id}.json"));
-    let before = std::fs::read(&path).unwrap();
-    let mut req = request(
-        oa,
-        sa,
-        vec![(
-            FacetSelector::Data(DataFacet::RecordSupertype),
-            SemanticDecision::TakeSource,
-        )],
-    );
-    let unresolved = preview(&server, &stored, &req).await;
-    assert!(
-        !unresolved["plan"]["conflicts"]
-            .as_array()
-            .unwrap()
-            .is_empty()
-    );
-    let impacts: Vec<SemanticImpact> =
-        serde_json::from_value(unresolved["plan"]["impacts"].clone()).unwrap();
-    assert_eq!(impacts.len(), 1);
-    assert_eq!(impacts[0].object, message);
-    assert_ne!(impacts[0].before, impacts[0].after);
-    assert_eq!(
-        post(&server, id, "apply", Some(&stored.etag()), &unresolved)
-            .await
-            .status(),
-        StatusCode::UNPROCESSABLE_ENTITY
-    );
-    let mut inaccurate = impacts.clone();
-    inaccurate[0].after = inaccurate[0].before.clone();
-    req.accepted_impacts = inaccurate;
-    let inaccurate = preview(&server, &stored, &req).await;
-    assert!(
-        !inaccurate["plan"]["conflicts"]
-            .as_array()
-            .unwrap()
-            .is_empty()
-    );
-    assert_eq!(std::fs::read(&path).unwrap(), before);
-    req.accepted_impacts = impacts;
-    let approved = preview(&server, &stored, &req).await;
-    assert_eq!(approved["plan"]["conflicts"], json!([]));
-    assert_eq!(
-        approved["plan"]["request"]["accepted_impacts"],
-        serde_json::to_value(&req.accepted_impacts).unwrap()
-    );
-    ok(post(&server, id, "apply", Some(&stored.etag()), &approved).await).await;
-    let current = server.get(id).await;
-    assert_eq!(current.revision, stored.revision + 1);
-    assert!(
-        matches!(current.model.elements[&message].shared(), Some(SharedBody::Occurrence { body: OccurrenceBody::Exchange { values, .. }, .. }) if values.is_empty())
-    );
-    assert_pair(&current);
-    server.stop().await;
-    let server = TestServer::start(directory.path(), None).await;
-    assert_eq!(server.get(id).await.model, current.model);
-    server.stop().await;
-}

crates/oa-server/tests/http/source_projects.rs

@@ -6,10 +6,10 @@ fn authored() -> SourceBundle {
     let bundle = SourceBundle {
         entry: "harbor.arcadia".into(),
         files: BTreeMap::from([
-            ("harbor.arcadia".into(), "// Harbor engineering rationale 航海\r\narcadia 4; project harbor \"Harbor rescue\" {\r\n include \"team/first.arcadia\";\r\n include \"team/second.arcadia\";\r\n include \"contracts.arcadia\";\r\n include \"work.arcadia\";\r\n}\r\n".into()),
+            ("harbor.arcadia".into(), "// Harbor engineering rationale 航海\r\narcadia 3; project harbor \"Harbor rescue\" {\r\n include \"team/first.arcadia\";\r\n include \"team/second.arcadia\";\r\n include \"contracts.arcadia\";\r\n include \"work.arcadia\";\r\n}\r\n".into()),
             ("team/first.arcadia".into(), "// First payload rationale\r\nsa_exchange_item first \"First payload\" { description \"Reviewed first\"; }\r\n".into()),
             ("team/second.arcadia".into(), "// Second payload rationale\r\nsa_exchange_item second \"Second payload\" {}\r\n".into()),
-            ("contracts.arcadia".into(), "// Contract ownership stays here\r\nsa_interface contract \"Contract\" {}\r\ninterface_item_allocation first_allocation \"First allocation\" { source @contract; target @first // first reference rationale\r\n; order 0; }\r\ninterface_item_allocation second_allocation \"Second allocation\" { source @contract; target @second // second reference rationale\r\n; order 1; }\r\n".into()),
+            ("contracts.arcadia".into(), "// Contract ownership stays here\r\nsa_interface contract \"Contract\" { items [\r\n @first // first reference rationale\r\n ,\r\n @second // second reference rationale\r\n ]; }\r\n".into()),
             ("work.arcadia".into(), "// Operational rationale\r\noa_activity assess \"Assess assistance\" {}\r\n".into()),
         ]),
     };

crates/oa-server/tests/semantic_http_contract.py

@@ -1,136 +0,0 @@
-"""Validate actual local HTTP responses against served and checked-in OpenAPI.
-
-Requires jsonschema. Usage: python semantic_http_contract.py /path/to/arcadia-server
-The supplied binary is launched on loopback with a fresh temporary store.
-"""
-import copy
-import json
-import os
-import re
-import subprocess
-import sys
-import tempfile
-import urllib.error
-import urllib.request
-from pathlib import Path
-
-from jsonschema import Draft202012Validator, FormatChecker
-
-ROOT = Path(__file__).resolve().parents[3]
-local = json.loads((ROOT / "docs/openapi.json").read_text(encoding="utf-8"))
-for schema in local["components"]["schemas"].values():
-    Draft202012Validator.check_schema(schema)
-
-
-def validator(spec, name):
-    return Draft202012Validator({"$ref": "#/components/schemas/" + name, "components": spec["components"]},
-                                format_checker=FormatChecker())
-
-
-with tempfile.TemporaryDirectory(prefix="arcadia-semantic-http-") as directory:
-    env = dict(os.environ)
-    env.pop("ARCADIA_SERVER_TOKEN", None)
-    process = subprocess.Popen([sys.argv[1], "--bind", "127.0.0.1:0", "--data-dir", directory],
-                               stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, env=env,
-                               creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0)
-    try:
-        banner = process.stderr.readline()
-        address = re.search(r"listening on (127\.0\.0\.1:\d+)", banner)
-        assert address, banner
-        base = "http://" + address.group(1)
-
-        def call(method, path, body=None, etag=None, expected=200):
-            headers = {"Content-Type": "application/json"}
-            if etag:
-                headers["If-Match"] = etag
-            request = urllib.request.Request(base + path, data=None if body is None else json.dumps(body).encode(),
-                                             headers=headers, method=method)
-            try:
-                response = urllib.request.urlopen(request, timeout=15)
-            except urllib.error.HTTPError as error:
-                response = error
-            with response:
-                data = json.load(response)
-                assert response.status == expected, (response.status, data)
-                return data, response.headers.get("ETag")
-
-        served, _ = call("GET", "/openapi.json")
-        assert served == local, "Server binary embeds a different OpenAPI file; rebuild it"
-        checked = 0
-
-        def validate(name, value):
-            global checked
-            for spec in (local, served):
-                validator(spec, name).validate(value)
-            checked += 1
-
-        old = json.loads((ROOT / "crates/oa-core/tests/fixtures/v4-reviewed-prose.json").read_text())
-        imported, etag = call("POST", "/api/v1/projects/import", old, expected=201)
-        path = "/api/v1/projects/" + imported["resource_id"]
-        stored, _ = call("GET", path)
-        validate("StoredProject", stored)
-        validate("Project", stored["model"])
-        trace = next(iter(stored["model"]["traces"]))
-        oa = stored["model"]["traces"][trace]["oa"]
-        sa = stored["model"]["traces"][trace]["sa"]
-        query = {"traces": [trace], "references": {oa: sa}, "revision": stored["revision"]}
-        validate("SemanticQueryRequest", query)
-        queried, _ = call("POST", path + "/semantic-transitions/query", query)
-        validate("SemanticQueryResult", queried)
-        request = {"transition": {"direction": "OaToSa", "sources": [oa], "scope": "SelectedOnly",
-                   "mappings": [{"source": oa, "target": sa, "target_kind": None}], "fields": [],
-                   "resolutions": [], "destination_diagram": None}, "traces": {oa: trace},
-                   "references": {}, "reviews": [{"source": oa, "resolutions": [
-                       {"facet": {"Header": "Name"}, "decision": "TakeSource"},
-                       {"facet": {"Data": "Unit"}, "decision": "KeepTarget"}], "reset": []}],
-                   "candidates": [], "accepted_impacts": []}
-        validate("SemanticTransitionRequest", request)
-        one_sided = copy.deepcopy(request)
-        one_sided["reviews"][0]["resolutions"] = [{"facet": {"Literal": {"oa": "Only source"}}, "decision": "KeepTarget"}]
-        validate("SemanticTransitionRequest", one_sided)
-        admitted, _ = call("POST", path + "/semantic-transitions/preview", one_sided, etag)
-        validate("SemanticTransitionEnvelope", admitted)
-        assert admitted["plan"]["conflicts"]  # Valid typed input, inapplicable to the integer/real fixture.
-        preview, _ = call("POST", path + "/semantic-transitions/preview", request, etag)
-        validate("SemanticTransitionEnvelope", preview)
-        assert not preview["plan"]["conflicts"], preview
-        result, updated_etag = call("POST", path + "/semantic-transitions/apply", preview, etag)
-        validate("MutationResult", result)
-        stored, _ = call("GET", path)
-        validate("StoredProject", stored)
-        validate("Project", stored["model"])
-        baseline = stored["model"]["traces"][trace]["baseline"]
-        validate("TraceBaseline", baseline)
-        validate("SemanticBaseline", baseline["semantic"])
-        query.pop("revision")
-        queried, _ = call("POST", path + "/semantic-transitions/query", query)
-        validate("SemanticQueryResult", queried)
-        problem, _ = call("POST", path + "/semantic-transitions/apply", preview, etag, expected=412)
-        validate("Problem", problem)
-        assert updated_etag != etag
-
-        invalid = [
-            ("FacetSelector", {"path": ["definition", "minimum"]}),
-            ("FacetSelector", {"Data": "Unsupported"}),
-            ("FacetReview", {"Data": {"IntegerMinimum": {"oa": {"Value": "wrong"}, "sa": {"Value": None}}}}),
-            ("FacetReview", {"Data": {"Unit": {"oa": {"Value": 42}, "sa": "NotApplicable"}}}),
-            ("FacetSelector", {"Literal": {"oa": "literal", "sa": None, "index": 0}}),
-            ("SemanticQueryRequest", {"traces": [trace, trace]}),
-            ("SemanticQueryRequest", {"traces": []}),
-            ("SemanticTransitionEnvelope", {**preview, "unknown": True}),
-        ]
-        obsolete = copy.deepcopy(stored["model"])
-        obsolete["schema_version"] = 4
-        invalid.append(("Project", obsolete))
-        for name, value in invalid:
-            assert not validator(local, name).is_valid(value), (name, value)
-            assert not validator(served, name).is_valid(value), (name, value)
-        # NotApplicable is distinct from Value(null); each leaf fixes the optionality.
-        validate("FacetReview", {"Data": {"IntegerMinimum": {"oa": "NotApplicable", "sa": {"Value": None}}}})
-        validate("FacetSelector", {"Annotation": {"oa": {"path": [oa], "field": sa}, "sa": None}})
-        validate("FacetSelector", {"Annotation": {"oa": {"path": [oa], "field": sa}}})
-        validate("SemanticImpact", {"object": oa, "after": {"Element": stored["model"]["elements"][oa]}})
-        print(f"{len(local['components']['schemas'])} valid schemas; {checked} actual/typed values validated against served+local contracts; {len(invalid)} invalid shapes rejected")
-    finally:
-        process.terminate()
-        process.wait(timeout=15)

crates/oa-server/tests/semantic_schema.py

@@ -1,205 +0,0 @@
-"""Refresh the closed semantic OpenAPI catalog from the frozen Rust leaf table.
-
-Run from any directory with Python 3: semantic_schema.py [--check].
-This generates documentation only, never runtime selectors or model mutations.
-"""
-import copy
-import json
-import re
-import sys
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[3]
-PATH = ROOT / "docs/openapi.json"
-spec = json.loads(PATH.read_text(encoding="utf-8"))
-schemas = spec["components"]["schemas"]
-types = (ROOT / "crates/oa-core/src/semantic/types.rs").read_text(encoding="utf-8")
-model = (ROOT / "crates/oa-core/src/model.rs").read_text(encoding="utf-8")
-
-
-def ref(name):
-    return {"$ref": f"#/components/schemas/{name}"}
-
-
-def obj(properties, required=None):
-    return {"type": "object", "properties": properties,
-            "required": list(properties) if required is None else required,
-            "additionalProperties": False}
-
-
-def array(item, maximum=None):
-    result = {"type": "array", "items": item}
-    if maximum is not None:
-        result["maxItems"] = maximum
-    return result
-
-
-def optional(item):
-    return {"anyOf": [item, {"type": "null"}]}
-
-
-def enum(names):
-    return {"type": "string", "enum": names}
-
-
-def variant(name, value):
-    return obj({name: value})
-
-
-def typed(name):
-    if name.startswith("Option<"):
-        return optional(typed(name[7:-1]))
-    if name.startswith("Vec<"):
-        return array(typed(name[4:-1]))
-    primitives = {"String": {"type": "string"}, "bool": {"type": "boolean"},
-                  "u32": {"type": "integer", "minimum": 0, "maximum": 4294967295},
-                  "i64": {"type": "integer", "minimum": -9223372036854775808,
-                          "maximum": 9223372036854775807}, "f64": {"type": "number"}}
-    return primitives[name] if name in primitives else ref(name)
-
-
-def reviewed(name):
-    key = "Reviewed" + re.sub(r"[^A-Za-z0-9]", "", name)
-    observation = {"oneOf": [enum(["NotApplicable"]), variant("Value", typed(name))]}
-    schemas[key] = obj({"oa": observation, "sa": copy.deepcopy(observation)})
-    return ref(key)
-
-
-def keypair(name):
-    key = "KeyPair" + name
-    schemas[key] = obj({"oa": optional(typed(name)), "sa": optional(typed(name))}, [])
-    return ref(key)
-
-
-for name in ["DataConstructor", "PortConstructor", "OccurrenceConstructor", "EventConstructor",
-             "MessageConstructor", "ReferenceCollection", "OrderedCollection", "IncidentEnd",
-             "ArtifactFacet", "ComponentPortKind", "ComponentPortOrientation", "PortDirection",
-             "FragmentOperator", "StateActionKind", "ArtifactRelation"]:
-    source = types if f"pub enum {name}" in types else model
-    body = re.search(r"pub enum " + name + r"\s*\{([^}]+)\}", source).group(1)
-    body = re.sub(r"//[^\n]*|#\[[^\]]*\]", "", body)
-    names = [value.strip() for value in body.split(",") if value.strip()]
-    assert all(re.fullmatch(r"[A-Za-z]+", value) for value in names), (name, names)
-    schemas[name] = enum(names)
-
-catalog = types.split("macro_rules! scalar_families", 1)[1].split("pub(super) use", 1)[0]
-families = re.findall(r"(\w+), (\w+), (\w+) \{([^}]+)\}", catalog)
-assert len(families) == 13
-selectors, reviews = [], []
-leaf_count = 0
-for family, selector, review, body in families:
-    leaves = re.findall(r"(\w+): ([\w<>]+)", body)
-    leaf_count += len(leaves)
-    schemas[selector] = enum([leaf for leaf, _ in leaves])
-    schemas[review] = {"oneOf": [variant(leaf, reviewed(value)) for leaf, value in leaves]}
-    selectors.append(variant(family, ref(selector)))
-    reviews.append(variant(family, ref(review)))
-assert leaf_count == 84
-schemas["AnnotationKey"] = obj({"path": array(ref("Id")), "field": ref("Id")})
-id_keys, text_keys, annotation_keys = keypair("Id"), keypair("String"), keypair("AnnotationKey")
-artifact_types = {"Presence": "bool", "Name": "String", "Description": "String", "Owner": "Id",
-                  "Relation": "ArtifactRelation", "Uri": "String", "Revision": "Option<String>",
-                  "Fragment": "Option<String>"}
-schemas["ArtifactReview"] = {"oneOf": [variant(k, reviewed(v)) for k, v in artifact_types.items()]}
-selectors += [variant("Member", obj({"collection": ref("ReferenceCollection"), "keys": id_keys})),
-              variant("Order", ref("OrderedCollection")), variant("Literal", text_keys),
-              variant("Annotation", annotation_keys), variant("Binding", id_keys), variant("Child", id_keys),
-              variant("Incident", obj({"keys": id_keys, "end": ref("IncidentEnd")})),
-              variant("Artifact", obj({"keys": id_keys, "facet": ref("ArtifactFacet")}))]
-reviews += [variant("Member", obj({"collection": ref("ReferenceCollection"), "keys": id_keys, "review": reviewed("bool")})),
-            variant("Order", obj({"collection": ref("OrderedCollection"), "review": reviewed("Vec<Id>")})),
-            variant("Literal", obj({"keys": text_keys, "review": reviewed("bool")})),
-            variant("Annotation", obj({"keys": annotation_keys, "review": reviewed("Option<MessageValue>")})),
-            variant("Binding", obj({"keys": id_keys, "review": reviewed("Option<LifelineBinding>")})),
-            variant("Child", obj({"keys": id_keys, "review": reviewed("bool")})),
-            variant("Incident", obj({"keys": id_keys, "end": ref("IncidentEnd"), "review": reviewed("bool")})),
-            variant("Artifact", obj({"keys": id_keys, "review": ref("ArtifactReview")}))]
-schemas["FacetSelector"] = {"oneOf": selectors}
-schemas["FacetReview"] = {"oneOf": reviews}
-schemas["SemanticBaseline"] = obj({"facets": array(ref("FacetReview"))})
-schemas["TraceBaseline"]["properties"]["semantic"] = {**optional(ref("SemanticBaseline")), "default": None,
-    "description": "Absent/null means Unreviewed. Historical typed facts never become live graph references."}
-schemas["Project"]["properties"]["schema_version"]["const"] = 5
-schemas["MigrationReport"]["properties"]["from_schema"]["enum"] = [1, 2, 3, 4]
-schemas["MigrationReport"]["properties"]["to_schema"]["const"] = 5
-schemas["MigrationReport"]["description"] = schemas["MigrationReport"]["description"].replace("V1/V2/V3 to V4", "V1/V2/V3/V4 to V5")
-spec["info"]["description"] = spec["info"]["description"].replace("schema-4", "schema-5")
-spec["paths"]["/api/v1/projects/import"]["post"]["description"] = "Schema-5 native JSON is described below. Schema-1/2/3/4 JSON and source are accepted through explicit frozen readers and migration, also on replacement and candidate validation. Prior prose reviews remain intact; absent semantic review stays Unreviewed. Export emits schema 5 / arcadia 5. See docs/language.rst."
-schemas["SourceBundle"]["description"] = schemas["SourceBundle"]["description"].replace("source4 workspace (source3 migrates explicitly)", "source5 workspace (source3/4 migrate explicitly)")
-schemas["Drift"] = enum(["Unreviewed", "Unchanged", "OaChanged", "SaChanged", "BothChanged"])
-schemas["FacetDrift"] = obj({"selector": ref("FacetSelector"), "current": ref("FacetReview"), "drift": ref("Drift")})
-schemas["SemanticDrift"] = obj({"own": ref("Drift"), "linked": ref("Drift"),
-    "own_unreviewed": typed("bool"), "linked_unreviewed": typed("bool")})
-schemas["LinkedSemanticImpact"] = obj({"objects": id_keys, "traces": array(ref("Id")),
-    "drift": ref("Drift"), "unreviewed": typed("bool")})
-for name, members in [("SemanticRecord", ["Element", "Relation", "Artifact"]),
-                      ("ImpactRecord", ["Element", "Relation", "Artifact", "Diagram", "Trace"])]:
-    schemas[name] = {"oneOf": [variant(n, ref("ArtifactLink" if n == "Artifact" else n)) for n in members]}
-schemas["SemanticImpact"] = obj({"object": ref("Id"), "before": optional(ref("ImpactRecord")), "after": optional(ref("ImpactRecord"))}, ["object"])
-schemas["SemanticDecision"] = enum(["KeepTarget", "TakeSource", "Candidate"])
-schemas["FacetResolution"] = obj({"facet": ref("FacetSelector"), "decision": ref("SemanticDecision")})
-schemas["SemanticReviewRequest"] = obj({"source": ref("Id"), "resolutions": array(ref("FacetResolution"), 5000),
-    "reset": {**array(ref("FacetSelector"), 5000), "default": []}}, ["source", "resolutions"])
-
-
-def mappings(maximum):
-    return {"type": "object", "propertyNames": {"format": "uuid"},
-            "additionalProperties": ref("Id"), "maxProperties": maximum, "default": {}}
-
-
-schemas["SemanticTransitionRequest"] = obj({"transition": ref("TransitionRequest"), "traces": mappings(100),
-    "references": mappings(5000), "reviews": {**array(ref("SemanticReviewRequest"), 100), "default": []},
-    "candidates": {**array(ref("SemanticRecord"), 200), "default": []},
-    "accepted_impacts": {**array(ref("SemanticImpact"), 200), "default": []}}, ["transition"])
-schemas["SemanticTransitionRequest"]["description"] = "Canonical OA-to-SA references include historical UUIDs. Traces map selected source IDs to trace IDs. Combined resolutions/reset limit: 5,000. Candidates must equal exactly the result of their selected facets; accepted_impacts explicitly acknowledge exact induced changes."
-schemas["SemanticReviewPreview"] = obj({"source": ref("Id"), "target": ref("Id"), "facets": array(ref("FacetDrift")),
-    "acknowledged": array(ref("FacetSelector")), "retired": array(ref("FacetSelector")), "linked_impacts": array(ref("LinkedSemanticImpact"))})
-schemas["SemanticTransitionPlan"] = obj({"base_fingerprint": typed("String"), "request": ref("SemanticTransitionRequest"),
-    "transition": ref("TransitionPlan"), "reviews": array(ref("SemanticReviewPreview")), "impacts": array(ref("SemanticImpact")),
-    "conflicts": array(typed("String")), "commands": array(ref("Command"), 200), "prepared_fingerprint": optional(typed("String"))})
-schemas["SemanticTransitionPlan"]["required"].remove("prepared_fingerprint")
-schemas["SemanticTransitionEnvelope"] = obj({"base_revision": ref("Revision"), "plan": ref("SemanticTransitionPlan")})
-schemas["SemanticQueryRequest"] = obj({"traces": {**array(ref("Id"), 100), "minItems": 1, "uniqueItems": True},
-    "references": mappings(5000), "revision": optional(ref("Revision"))}, ["traces"])
-schemas["SemanticQueryItem"] = obj({"trace": ref("Id"), "oa": ref("Id"), "sa": ref("Id"),
-    "facets": array(ref("FacetDrift")), "drift": ref("SemanticDrift"), "linked_impacts": array(ref("LinkedSemanticImpact"))})
-schemas["SemanticQueryResult"] = obj({"revision": ref("Revision"), "items": array(ref("SemanticQueryItem"), 100)})
-for operation, request, result in [("query", "SemanticQueryRequest", "SemanticQueryResult"),
-        ("preview", "SemanticTransitionRequest", "SemanticTransitionEnvelope"),
-        ("apply", "SemanticTransitionEnvelope", "MutationResult")]:
-    endpoint = copy.deepcopy(spec["paths"]["/api/v1/projects/{id}/transitions/" + ("apply" if operation == "apply" else "preview")])
-    post = endpoint["post"]
-    post["operationId"] = operation + "SemanticTransition"
-    post["summary"] = {"query": "Query typed trace drift and linked impacts without mutation",
-        "preview": "Preview and source-validate a typed semantic transition without writing",
-        "apply": "Conditionally apply a prepared semantic candidate in one model/source revision"}[operation]
-    post["requestBody"]["content"]["application/json"]["schema"] = ref(request)
-    post["responses"]["200"]["content"]["application/json"]["schema"] = ref(result)
-    post["description"] = "Uses the frozen core typed semantic contract. A supplied plan is a client-owned candidate, not a signed receipt; fingerprints check consistency, not original review authorship. Preview validates source writeback when conflict-free. Apply preserves preview-generated IDs and does not replan random identities."
-    if operation == "query":
-        post["parameters"] = [p for p in post["parameters"] if p["in"] != "header"]
-        post["responses"].pop("412", None)
-        post["responses"].pop("428", None)
-        post["responses"]["409"] = {"$ref": "#/components/responses/Problem"}
-        post["description"] = "Read one immutable snapshot. Optional revision mismatch returns409; missing trace returns404; duplicate/empty trace selection returns400. References are canonical OA-to-SA correspondence. No write, baseline refresh or external artifact fetch."
-    spec["paths"]["/api/v1/projects/{id}/semantic-transitions/" + operation] = endpoint
-
-
-def check_refs(value):
-    if isinstance(value, dict):
-        if "$ref" in value and value["$ref"].startswith("#/components/schemas/"):
-            assert value["$ref"].split("/")[-1] in schemas, value
-        for child in value.values():
-            check_refs(child)
-    elif isinstance(value, list):
-        for child in value:
-            check_refs(child)
-
-
-check_refs(spec)
-rendered = json.dumps(spec, indent=2, ensure_ascii=False) + "\n"
-if "--check" in sys.argv:
-    assert json.loads(PATH.read_text(encoding="utf-8")) == spec, "Run semantic_schema.py to refresh OpenAPI"
-else:
-    PATH.write_text(rendered, encoding="utf-8")
-print(f"Closed catalog: {len(families)} families, {leaf_count} scalar leaves; {len(schemas)} schemas")

docs/api.html

@@ -763,18 +763,6 @@ bearer token, if any. Non-loopback binding requires a configured token.</p>
 <td><p><span class="docutils literal"><span class="pre">/api/v1/projects/{id}/transitions/apply</span></span></p></td>
 <td><p>Conditionally apply that client-held plan and base_revision.</p></td>
 </tr>
-<tr><td><p>POST</p></td>
-<td><p><span class="docutils literal"><span class="pre">/api/v1/projects/{id}/semantic-transitions/query</span></span></p></td>
-<td><p>Read selected traces' typed facts, own drift and linked impacts.</p></td>
-</tr>
-<tr><td><p>POST</p></td>
-<td><p><span class="docutils literal"><span class="pre">/api/v1/projects/{id}/semantic-transitions/preview</span></span></p></td>
-<td><p>Prepare typed semantic decisions and source writeback without writing.</p></td>
-</tr>
-<tr><td><p>POST</p></td>
-<td><p><span class="docutils literal"><span class="pre">/api/v1/projects/{id}/semantic-transitions/apply</span></span></p></td>
-<td><p>Apply that prepared candidate under its original shared revision/ETag.</p></td>
-</tr>
 </tbody>
 </table>
 <p><span class="docutils literal"><span class="pre">Content-Type:</span> application/json</span> is required for JSON requests.
@@ -796,8 +784,8 @@ candidate validation reports the same diagnostic in its 200 response.
 Parsing, validation and query processing use snapshot workers, so this work
 does not hold the catalog lock or serialize unrelated model preparation.</p>
 <p>Import accepts schema-1 JSON through the shared explicit migration adapter,
-as well as schema-2, schema-3, schema-4 and current schema-5 JSON. Source import uses the shared language parser
-and its supported migrations. Export uses schema 5 / arcadia 5. Native JSON
+as well as schema-2 native JSON. Source import uses the shared language parser
+and its supported migrations. Export uses schema 3 / arcadia 3. Native JSON
 replacement accepts supported older schemas through the same explicit migration.
 Only documented query parameters are accepted. In particular, appending
 <span class="docutils literal"><span class="pre">?revision=...</span></span> to model/source export is an error, not historical retrieval.</p>
@@ -808,7 +796,7 @@ Only documented query parameters are accepted. In particular, appending
 <pre class="literal-block">{
   &quot;entry&quot;: &quot;rescue.arcadia&quot;,
   &quot;files&quot;: {
-    &quot;rescue.arcadia&quot;: &quot;arcadia 5; project rescue \&quot;Rescue\&quot; { include \&quot;oa/work.arcadia\&quot;; }\n&quot;,
+    &quot;rescue.arcadia&quot;: &quot;arcadia 3; project rescue \&quot;Rescue\&quot; { include \&quot;oa/work.arcadia\&quot;; }\n&quot;,
     &quot;oa/work.arcadia&quot;: &quot;// Engineering rationale\noa_activity assess \&quot;Assess assistance\&quot; {}\n&quot;
   }
 }</pre>
@@ -819,9 +807,8 @@ targets or another hosted resource. All submitted files must be reachable;
 missing files, cycles, duplicate keys, case collisions and escaping paths are
 rejected. The bundle permits at most 256 files, 32 include edges along a path,
 and 1,024 include edges in total. Model and source-byte budgets apply across
-the complete bundle, not separately per file. Current bundle syntax is source5; source3/4 bundles migrate explicitly while
-preserving their files/includes/comments. V1/V2 single-file migration remains
-available through interchange import.</p>
+the complete bundle, not separately per file. Bundle syntax is source3;
+single-file legacy migration remains available through interchange import.</p>
 <p>Compilation inserts UUIDs into headers that omit them. Import returns 201 with
 Location/ETag; GET source-project retrieves the stabilized accepted bundle.
 PUT returns <span class="docutils literal">revision</span>, <span class="docutils literal">changed</span>, located <span class="docutils literal">issues</span> and that accepted
@@ -978,11 +965,8 @@ does not execute conditions or simulate a process.</p>
 store <span class="docutils literal">message_kind</span>, optional correlated-call <span class="docutils literal">reply_to</span> and contextual
 <span class="docutils literal">values</span>. Message kinds are Asynchronous, Call, Reply, Create, Delete, or
 <span class="docutils literal"><span class="pre">{&quot;Timer&quot;:{&quot;expression&quot;:&quot;after</span> 5 <span class="pre">s&quot;}}</span></span>. Each value record contains a
-carried DataField UUID in <span class="docutils literal">field</span>, enclosing field UUID list <span class="docutils literal">path</span> (default
-[]) and textual <span class="docutils literal">expression</span>. Identity is (path, field), allowing repeated uses
-of a Record. Operation Call/Reply direction checks use the direct parameter;
-Reference storage stops nested payload traversal. Expressions do not change the
-shared exchange item's type or evaluate server-side.</p>
+carried DataField UUID in <span class="docutils literal">field</span> and its textual <span class="docutils literal">expression</span>; expressions
+do not change the shared exchange item's type or evaluate server-side.</p>
 <p><span class="docutils literal">ScenarioUse</span> contains a referenced <span class="docutils literal">scenario</span> and one-to-one lifeline
 <span class="docutils literal">bindings</span> records with <span class="docutils literal">referenced</span> and <span class="docutils literal">local</span> UUIDs. The core validates
 viewpoint/layer compatibility, call/reply order and reversal, lifetime order,
@@ -994,26 +978,6 @@ exports make those compatibility defaults explicit. This preserves original V2
 models while the release schema is being integrated; it does not silently
 reinterpret old mixed lifelines as a strict new viewpoint.</p>
 </section>
-<section id="data-and-interface-contracts">
-<h2>Data and interface contracts</h2>
-<p>Schema4 uses typed bounded DataTypeDefinition and DataValue constructors, field
-storage/defaults/directions, and single specialization. Exact JSON shapes are in
-<span class="docutils literal">openapi.json</span> and semantic rules and runnable source in <span class="docutils literal">language.rst</span> section 4.5.
-Interface membership is an identified InterfaceItemAllocation relation with
-independent order/transmission/acquisition. DataAssociation relates Record types
-with named, navigable, multiplicity-bearing ends; it does not add carried fields.</p>
-<p>Use ordinary relation queries, transactions and artifact links, for example
-<span class="docutils literal">GET <span class="pre">/api/v1/projects/{id}/relations?kind=InterfaceItemAllocation</span></span>. The service
-and desktop use the same inheritance/path/default validation. Invalid bounds,
-defaults, directions, cycles or contract-breaking deletions reject atomically,
-preserving the accepted source/model, revision and stored bytes. Correct a related
-contract in the same transaction when removing a used interface allocation.</p>
-<p>Explicit schema1/2/3 migration preserves prior identities and typed ports. Reports
-add semantic defaults, generated interface allocations and unresolved message
-values. Old source3 bundles retain files/includes/comments during upgrade; all
-current exports use schema5/source5. Reading an old envelope does not write it or
-advance its ETag. Canonical exports omit transient migration reports.</p>
-</section>
 <section id="validation">
 <h2>Validation</h2>
 <p>GET returns current-model diagnostics. POST accepts either:</p>
@@ -1021,7 +985,7 @@ advance its ETag. Canonical exports omit transient migration reports.</p>
 <p>or:</p>
 <pre class="literal-block">{&quot;format&quot;:&quot;arcadia&quot;, &quot;source&quot;:&quot;complete source document&quot;}</pre>
 <p>or:</p>
-<pre class="literal-block">{&quot;format&quot;:&quot;source-project&quot;, &quot;source_project&quot;:{&quot;entry&quot;:&quot;rescue.arcadia&quot;, &quot;files&quot;:{&quot;rescue.arcadia&quot;:&quot;arcadia 5; project rescue \&quot;Rescue\&quot; {}&quot;}}}</pre>
+<pre class="literal-block">{&quot;format&quot;:&quot;source-project&quot;, &quot;source_project&quot;:{&quot;entry&quot;:&quot;rescue.arcadia&quot;, &quot;files&quot;:{&quot;rescue.arcadia&quot;:&quot;arcadia 3; project rescue \&quot;Rescue\&quot; {}&quot;}}}</pre>
 <p>A well-formed validation request returns 200 with <span class="docutils literal">valid</span> and <span class="docutils literal">issues</span> even
 if its candidate is invalid, including a model record that fails typed decoding.
 Malformed request JSON or an invalid format/payload envelope is a 400.
@@ -1105,102 +1069,6 @@ authenticated as an untouched server preview; the same authenticated client
 can submit ordinary typed commands. The core fingerprint is a change detector,
 not a security digest. There is no plan token, expiration store or receipt.</p>
 </section>
-<section id="typed-semantic-transition-review">
-<h2>Typed semantic transition review</h2>
-<p>The sibling <span class="docutils literal"><span class="pre">semantic-transitions</span></span> routes use the <a class="reference external" href="language.html#typed-semantic-review-facts">typed review semantics</a> in <span class="docutils literal">language.rst</span> sections 5.1–5.5.
-The original prose transition routes keep
-their existing contract. All new routes use JSON and the existing authentication,
-capacity, worker and error boundaries.</p>
-<p>Query accepts <span class="docutils literal"><span class="pre">{&quot;traces&quot;:[&quot;trace-uuid&quot;],&quot;references&quot;:{},&quot;revision&quot;:1}</span></span>.
-<span class="docutils literal">references</span> is an optional map of canonical OA UUIDs to SA UUIDs, including
-historical deleted identities. It never guesses correspondences from names.
-<span class="docutils literal">revision</span> is optional; a mismatch returns 409. Select 1–100 unique existing
-trace IDs; an empty or duplicate selection returns 400 and a missing trace
-returns 404. The response includes the current revision and items containing
-<span class="docutils literal">trace</span>, <span class="docutils literal">oa</span>, <span class="docutils literal">sa</span>, typed <span class="docutils literal">facets</span>, <span class="docutils literal">drift</span> and <span class="docutils literal">linked_impacts</span>.
-Own and linked drift and their unreviewed flags remain distinct. Query reads one
-immutable snapshot, does not refresh baselines, and does not fetch artifact URIs.</p>
-<p>Preview accepts <span class="docutils literal">SemanticTransitionRequest</span>:</p>
-<pre class="literal-block">{
-  &quot;transition&quot;: {
-    &quot;direction&quot;: &quot;OaToSa&quot;,
-    &quot;sources&quot;: [&quot;40000000-0000-4000-8000-000000000002&quot;],
-    &quot;scope&quot;: &quot;SelectedOnly&quot;,
-    &quot;mappings&quot;: [{
-      &quot;source&quot;: &quot;40000000-0000-4000-8000-000000000002&quot;,
-      &quot;target&quot;: &quot;40000000-0000-4000-8000-000000000003&quot;,
-      &quot;target_kind&quot;: null
-    }],
-    &quot;fields&quot;: [], &quot;resolutions&quot;: [], &quot;destination_diagram&quot;: null
-  },
-  &quot;traces&quot;: {}, &quot;references&quot;: {},
-  &quot;reviews&quot;: [{
-    &quot;source&quot;: &quot;40000000-0000-4000-8000-000000000002&quot;,
-    &quot;resolutions&quot;: [
-      {&quot;facet&quot;:{&quot;Header&quot;:&quot;Name&quot;}, &quot;decision&quot;:&quot;TakeSource&quot;},
-      {&quot;facet&quot;:{&quot;Data&quot;:&quot;Unit&quot;}, &quot;decision&quot;:&quot;KeepTarget&quot;}
-    ],
-    &quot;reset&quot;: []
-  }],
-  &quot;candidates&quot;: [], &quot;accepted_impacts&quot;: []
-}</pre>
-<p>The example maps an existing OA data type to its traced SA counterpart, takes
-only its name and acknowledges intentionally different units. Other facets stay
-unreviewed or retain their earlier drift. Select an explicit trace through the
-<span class="docutils literal">traces</span> map (source UUID to trace UUID) when multiple trace kinds connect the
-pair. <span class="docutils literal">reset</span> deliberately invalidates exact old selectors after changed
-correspondence. The optional collections default to empty. Semantic header
-decisions use typed facets; leave legacy <span class="docutils literal">transition.fields</span> and
-<span class="docutils literal">transition.resolutions</span> empty.</p>
-<p>Facet selectors are closed enums, for example <span class="docutils literal"><span class="pre">{&quot;Data&quot;:&quot;IntegerMinimum&quot;}</span></span>
-or <span class="docutils literal"><span class="pre">{&quot;Member&quot;:{&quot;collection&quot;:&quot;SignalItems&quot;,&quot;keys&quot;:{&quot;oa&quot;:&quot;oa-uuid&quot;,&quot;sa&quot;:&quot;sa-uuid&quot;}}}</span></span>.
-Annotation keys contain the entire path and field; enum literal keys are exact
-strings. <span class="docutils literal">KeepTarget</span>, <span class="docutils literal">TakeSource</span> and <span class="docutils literal">Candidate</span> operate on independently
-selected facts. Candidate records use existing Element/Relation/ArtifactLink
-types, must preserve identity/alias, and must equal precisely the result of
-the selected facets. Constructor review covers its coupled introduced/removed
-fields. Membership review does not silently acknowledge order; target-only
-members remain independent. OpenAPI defines every selector and typed payload.</p>
-<p>Preview requires <span class="docutils literal"><span class="pre">If-Match</span></span> and returns <span class="docutils literal"><span class="pre">{&quot;base_revision&quot;:1,&quot;plan&quot;:{...}}</span></span>.
-The plan contains the original typed request, mapping plan, review facts,
-acknowledged/retired selectors, linked impacts, exact prepared impacts, conflicts,
-commands, and base/prepared fingerprints. A conflict-free preview also prepares
-the complete authored source bundle and checks its model equivalence and capacity.
-No preview changes the model, source, revision or stored bytes.</p>
-<p>If ordinary preparation induces additional cleanup, the plan reports exact typed
-before/after impacts and a conflict. Review those impacts, place the accepted
-records in <span class="docutils literal">accepted_impacts</span>, and request another preview. Acceptance cannot
-override a contradictory selected facet. Missing mappings, ambiguous order,
-duplicate decisions, invalid candidates or unresolved impacts cannot be applied.
-This is the shared core planner and command preparation, with no server-specific
-semantic mutation engine.</p>
-<p>Apply accepts the entire preview envelope under the same <span class="docutils literal"><span class="pre">If-Match</span></span>. It checks
-<span class="docutils literal">base_revision</span>, the model fingerprint, unresolved conflicts, the prepared
-candidate fingerprint, ordinary model validation and coupled source preparation,
-then atomically stores one accepted model/source revision. The final store check
-also catches a concurrent edit during preparation. Source-only edits invalidate
-the preview through the shared ETag even when the model fingerprint is unchanged.
-Stale ETag/revision returns 412; semantic rejection returns 422 with code
-<span class="docutils literal">semantic_transition_rejected</span>. Exact no-op candidates preserve revision.
-Read and preview again after a successful changed apply before reviewing further.</p>
-<p>A supplied plan remains a client-owned candidate. Fingerprints detect stale or
-inconsistent proposals; they are not tamper-proof signatures, authentication
-receipts or proof of original review authorship. Apply preserves preview-generated
-identities and does not rerun the planner with fresh random IDs. Authenticated
-clients already have ordinary model/source editing privileges. The server does
-not persist plans, tokens or review sessions.</p>
-<p>Requests allow 100 sources, trace choices and reviews; 200 mappings, candidates
-and accepted impacts; 5,000 canonical reference mappings; and 5,000 facet
-resolutions plus resets across all reviews. The legacy 400 prose-resolution
-limit and 200-command transaction limit still apply. Query has the same 5,000
-reference-map limit. Core bounded linked traversal errors remain observable as
-semantic rejection; no truncated result silently claims complete review.</p>
-<p>Schema/source 5 adds <span class="docutils literal">TraceBaseline.semantic</span>. Absence or null is Unreviewed;
-migrating older prose baselines does not fabricate semantic history. The persisted
-baseline contains only closed typed <span class="docutils literal">FacetReview</span> facts, not whole candidate
-records or a generic JSON value tree. Historical UUIDs remain historical, including
-after deletion, and source uses explicit <span class="docutils literal">uuid</span> tokens for them.</p>
-</section>
 <section id="error-contract">
 <h2>Error contract</h2>
 <p>All errors have <span class="docutils literal"><span class="pre">Content-Type:</span> application/problem+json</span>. Example:</p>

docs/api.rst

@@ -124,15 +124,6 @@ bearer token, if any. Non-loopback binding requires a configured token.
    * - POST
      - ``/api/v1/projects/{id}/transitions/apply``
      - Conditionally apply that client-held plan and base_revision.
-   * - POST
-     - ``/api/v1/projects/{id}/semantic-transitions/query``
-     - Read selected traces' typed facts, own drift and linked impacts.
-   * - POST
-     - ``/api/v1/projects/{id}/semantic-transitions/preview``
-     - Prepare typed semantic decisions and source writeback without writing.
-   * - POST
-     - ``/api/v1/projects/{id}/semantic-transitions/apply``
-     - Apply that prepared candidate under its original shared revision/ETag.
 
 ``Content-Type: application/json`` is required for JSON requests.
 ``text/plain; charset=utf-8`` is used for Arcadia source. The service does not
@@ -155,8 +146,8 @@ Parsing, validation and query processing use snapshot workers, so this work
 does not hold the catalog lock or serialize unrelated model preparation.
 
 Import accepts schema-1 JSON through the shared explicit migration adapter,
-as well as schema-2, schema-3, schema-4 and current schema-5 JSON. Source import uses the shared language parser
-and its supported migrations. Export uses schema 5 / arcadia 5. Native JSON
+as well as schema-2 native JSON. Source import uses the shared language parser
+and its supported migrations. Export uses schema 3 / arcadia 3. Native JSON
 replacement accepts supported older schemas through the same explicit migration.
 Only documented query parameters are accepted. In particular, appending
 ``?revision=...`` to model/source export is an error, not historical retrieval.
@@ -169,7 +160,7 @@ A source bundle contains ``entry`` and a map of ``files``. For example::
     {
       "entry": "rescue.arcadia",
       "files": {
-        "rescue.arcadia": "arcadia 5; project rescue \"Rescue\" { include \"oa/work.arcadia\"; }\n",
+        "rescue.arcadia": "arcadia 3; project rescue \"Rescue\" { include \"oa/work.arcadia\"; }\n",
         "oa/work.arcadia": "// Engineering rationale\noa_activity assess \"Assess assistance\" {}\n"
       }
     }
@@ -181,9 +172,8 @@ targets or another hosted resource. All submitted files must be reachable;
 missing files, cycles, duplicate keys, case collisions and escaping paths are
 rejected. The bundle permits at most 256 files, 32 include edges along a path,
 and 1,024 include edges in total. Model and source-byte budgets apply across
-the complete bundle, not separately per file. Current bundle syntax is source5; source3/4 bundles migrate explicitly while
-preserving their files/includes/comments. V1/V2 single-file migration remains
-available through interchange import.
+the complete bundle, not separately per file. Bundle syntax is source3;
+single-file legacy migration remains available through interchange import.
 
 Compilation inserts UUIDs into headers that omit them. Import returns 201 with
 Location/ETag; GET source-project retrieves the stabilized accepted bundle.
@@ -365,11 +355,8 @@ Scenario bodies store an explicit ``viewpoint``. Occurrence Exchange bodies
 store ``message_kind``, optional correlated-call ``reply_to`` and contextual
 ``values``. Message kinds are Asynchronous, Call, Reply, Create, Delete, or
 ``{"Timer":{"expression":"after 5 s"}}``. Each value record contains a
-carried DataField UUID in ``field``, enclosing field UUID list ``path`` (default
-[]) and textual ``expression``. Identity is (path, field), allowing repeated uses
-of a Record. Operation Call/Reply direction checks use the direct parameter;
-Reference storage stops nested payload traversal. Expressions do not change the
-shared exchange item's type or evaluate server-side.
+carried DataField UUID in ``field`` and its textual ``expression``; expressions
+do not change the shared exchange item's type or evaluate server-side.
 
 ``ScenarioUse`` contains a referenced ``scenario`` and one-to-one lifeline
 ``bindings`` records with ``referenced`` and ``local`` UUIDs. The core validates
@@ -383,29 +370,6 @@ exports make those compatibility defaults explicit. This preserves original V2
 models while the release schema is being integrated; it does not silently
 reinterpret old mixed lifelines as a strict new viewpoint.
 
-Data and interface contracts
-----------------------------
-
-Schema4 uses typed bounded DataTypeDefinition and DataValue constructors, field
-storage/defaults/directions, and single specialization. Exact JSON shapes are in
-``openapi.json`` and semantic rules and runnable source in ``language.rst`` section 4.5.
-Interface membership is an identified InterfaceItemAllocation relation with
-independent order/transmission/acquisition. DataAssociation relates Record types
-with named, navigable, multiplicity-bearing ends; it does not add carried fields.
-
-Use ordinary relation queries, transactions and artifact links, for example
-``GET /api/v1/projects/{id}/relations?kind=InterfaceItemAllocation``. The service
-and desktop use the same inheritance/path/default validation. Invalid bounds,
-defaults, directions, cycles or contract-breaking deletions reject atomically,
-preserving the accepted source/model, revision and stored bytes. Correct a related
-contract in the same transaction when removing a used interface allocation.
-
-Explicit schema1/2/3 migration preserves prior identities and typed ports. Reports
-add semantic defaults, generated interface allocations and unresolved message
-values. Old source3 bundles retain files/includes/comments during upgrade; all
-current exports use schema5/source5. Reading an old envelope does not write it or
-advance its ETag. Canonical exports omit transient migration reports.
-
 Validation
 ----------
 
@@ -419,7 +383,7 @@ or::
 
 or::
 
-    {"format":"source-project", "source_project":{"entry":"rescue.arcadia", "files":{"rescue.arcadia":"arcadia 5; project rescue \"Rescue\" {}"}}}
+    {"format":"source-project", "source_project":{"entry":"rescue.arcadia", "files":{"rescue.arcadia":"arcadia 3; project rescue \"Rescue\" {}"}}}
 
 A well-formed validation request returns 200 with ``valid`` and ``issues`` even
 if its candidate is invalid, including a model record that fails typed decoding.
@@ -515,115 +479,6 @@ authenticated as an untouched server preview; the same authenticated client
 can submit ordinary typed commands. The core fingerprint is a change detector,
 not a security digest. There is no plan token, expiration store or receipt.
 
-Typed semantic transition review
---------------------------------
-
-The sibling ``semantic-transitions`` routes use the `typed review semantics
-<language.html#typed-semantic-review-facts>`_ in ``language.rst`` sections 5.1–5.5.
-The original prose transition routes keep
-their existing contract. All new routes use JSON and the existing authentication,
-capacity, worker and error boundaries.
-
-Query accepts ``{"traces":["trace-uuid"],"references":{},"revision":1}``.
-``references`` is an optional map of canonical OA UUIDs to SA UUIDs, including
-historical deleted identities. It never guesses correspondences from names.
-``revision`` is optional; a mismatch returns 409. Select 1–100 unique existing
-trace IDs; an empty or duplicate selection returns 400 and a missing trace
-returns 404. The response includes the current revision and items containing
-``trace``, ``oa``, ``sa``, typed ``facets``, ``drift`` and ``linked_impacts``.
-Own and linked drift and their unreviewed flags remain distinct. Query reads one
-immutable snapshot, does not refresh baselines, and does not fetch artifact URIs.
-
-Preview accepts ``SemanticTransitionRequest``::
-
-    {
-      "transition": {
-        "direction": "OaToSa",
-        "sources": ["40000000-0000-4000-8000-000000000002"],
-        "scope": "SelectedOnly",
-        "mappings": [{
-          "source": "40000000-0000-4000-8000-000000000002",
-          "target": "40000000-0000-4000-8000-000000000003",
-          "target_kind": null
-        }],
-        "fields": [], "resolutions": [], "destination_diagram": null
-      },
-      "traces": {}, "references": {},
-      "reviews": [{
-        "source": "40000000-0000-4000-8000-000000000002",
-        "resolutions": [
-          {"facet":{"Header":"Name"}, "decision":"TakeSource"},
-          {"facet":{"Data":"Unit"}, "decision":"KeepTarget"}
-        ],
-        "reset": []
-      }],
-      "candidates": [], "accepted_impacts": []
-    }
-
-The example maps an existing OA data type to its traced SA counterpart, takes
-only its name and acknowledges intentionally different units. Other facets stay
-unreviewed or retain their earlier drift. Select an explicit trace through the
-``traces`` map (source UUID to trace UUID) when multiple trace kinds connect the
-pair. ``reset`` deliberately invalidates exact old selectors after changed
-correspondence. The optional collections default to empty. Semantic header
-decisions use typed facets; leave legacy ``transition.fields`` and
-``transition.resolutions`` empty.
-
-Facet selectors are closed enums, for example ``{"Data":"IntegerMinimum"}``
-or ``{"Member":{"collection":"SignalItems","keys":{"oa":"oa-uuid","sa":"sa-uuid"}}}``.
-Annotation keys contain the entire path and field; enum literal keys are exact
-strings. ``KeepTarget``, ``TakeSource`` and ``Candidate`` operate on independently
-selected facts. Candidate records use existing Element/Relation/ArtifactLink
-types, must preserve identity/alias, and must equal precisely the result of
-the selected facets. Constructor review covers its coupled introduced/removed
-fields. Membership review does not silently acknowledge order; target-only
-members remain independent. OpenAPI defines every selector and typed payload.
-
-Preview requires ``If-Match`` and returns ``{"base_revision":1,"plan":{...}}``.
-The plan contains the original typed request, mapping plan, review facts,
-acknowledged/retired selectors, linked impacts, exact prepared impacts, conflicts,
-commands, and base/prepared fingerprints. A conflict-free preview also prepares
-the complete authored source bundle and checks its model equivalence and capacity.
-No preview changes the model, source, revision or stored bytes.
-
-If ordinary preparation induces additional cleanup, the plan reports exact typed
-before/after impacts and a conflict. Review those impacts, place the accepted
-records in ``accepted_impacts``, and request another preview. Acceptance cannot
-override a contradictory selected facet. Missing mappings, ambiguous order,
-duplicate decisions, invalid candidates or unresolved impacts cannot be applied.
-This is the shared core planner and command preparation, with no server-specific
-semantic mutation engine.
-
-Apply accepts the entire preview envelope under the same ``If-Match``. It checks
-``base_revision``, the model fingerprint, unresolved conflicts, the prepared
-candidate fingerprint, ordinary model validation and coupled source preparation,
-then atomically stores one accepted model/source revision. The final store check
-also catches a concurrent edit during preparation. Source-only edits invalidate
-the preview through the shared ETag even when the model fingerprint is unchanged.
-Stale ETag/revision returns 412; semantic rejection returns 422 with code
-``semantic_transition_rejected``. Exact no-op candidates preserve revision.
-Read and preview again after a successful changed apply before reviewing further.
-
-A supplied plan remains a client-owned candidate. Fingerprints detect stale or
-inconsistent proposals; they are not tamper-proof signatures, authentication
-receipts or proof of original review authorship. Apply preserves preview-generated
-identities and does not rerun the planner with fresh random IDs. Authenticated
-clients already have ordinary model/source editing privileges. The server does
-not persist plans, tokens or review sessions.
-
-Requests allow 100 sources, trace choices and reviews; 200 mappings, candidates
-and accepted impacts; 5,000 canonical reference mappings; and 5,000 facet
-resolutions plus resets across all reviews. The legacy 400 prose-resolution
-limit and 200-command transaction limit still apply. Query has the same 5,000
-reference-map limit. Core bounded linked traversal errors remain observable as
-semantic rejection; no truncated result silently claims complete review.
-
-Schema/source 5 adds ``TraceBaseline.semantic``. Absence or null is Unreviewed;
-migrating older prose baselines does not fabricate semantic history. The persisted
-baseline contains only closed typed ``FacetReview`` facts, not whole candidate
-records or a generic JSON value tree. Historical UUIDs remain historical, including
-after deletion, and source uses explicit ``uuid`` tokens for them.
-
 Error contract
 --------------
 

docs/language.html

@@ -623,7 +623,7 @@ a { text-decoration: none; }
 <h1 class="title">Arcadia Studio OA / SA Language and Editing Contract</h1>
 <dl class="docinfo simple">
 <dt class="version">Version<span class="colon">:</span></dt>
-<dd class="version">5</dd>
+<dd class="version">3</dd>
 <dt class="status">Status<span class="colon">:</span></dt>
 <dd class="status">Normative current implementation contract; first-release integration</dd>
 <dt class="core-implementation">Core implementation<span class="colon">:</span></dt>
@@ -637,15 +637,14 @@ a { text-decoration: none; }
 <h2>1. Scope and conformance</h2>
 <p>This specification defines the shared Operational Analysis (OA) and System
 Analysis (SA) model, its textual language, graphical editing obligations,
-validation, persistence, and explicit migration from versions 1, 2, 3 and 4. MUST, MUST NOT,
+validation, persistence, and explicit migration from versions 1 and 2. MUST, MUST NOT,
 and MAY indicate requirements, prohibitions, and permitted choices.</p>
-<p>Schema 5 adds closed typed semantic review facts to trace baselines, including
-historical references that may no longer exist in the live model. It retains
-schema 4 bounded reusable data types, typed defaults, exchange mechanisms,
-qualified values, specialization, interface allocations and associations, and
-schema 3 typed ports and state views. Explicit older readers preserve meanings
-and identities without inventing previously reviewed semantic values.
-This contract does not by itself establish native acceptance or release completion.</p>
+<p>Schema 3 introduces typed function and component ports, required functional
+exchange endpoints, independently oriented boundary exchanges, and explicit
+PortAllocation relations. First-release scenario/state additions remain in
+scope; this schema change does not declare native acceptance or the wider
+release complete. The preserved schema-2 reader validates the original
+contract before migration.</p>
 <p>OA describes stakeholders, operational work and needs. SA describes the
 selected system boundary, external actors, functions, services and expected
 behavior. SA permits at most one System of Interest; its absence is an
@@ -663,7 +662,7 @@ Actual verification evidence is separate from this contract.</p>
 </section>
 <section id="one-authoritative-model">
 <h2>2. One authoritative model</h2>
-<p>A Project stores <span class="docutils literal">schema_version</span> (5), <span class="docutils literal">id</span>, <span class="docutils literal">alias</span>, <span class="docutils literal">name</span>,
+<p>A Project stores <span class="docutils literal">schema_version</span> (3), <span class="docutils literal">id</span>, <span class="docutils literal">alias</span>, <span class="docutils literal">name</span>,
 <span class="docutils literal">description</span>, and maps named <span class="docutils literal">elements</span>, <span class="docutils literal">relations</span>, <span class="docutils literal">diagrams</span>,
 <span class="docutils literal">artifact_links</span>, and <span class="docutils literal">traces</span>. Each map is keyed by the UUID contained in
 its record. Duplicate map keys and mismatching keys/identities are errors.</p>
@@ -723,20 +722,20 @@ lists all additional fields. <span class="docutils literal">ref</span> means <sp
 <td><p><span class="docutils literal">[]</span></p></td>
 </tr>
 <tr><td><p><span class="docutils literal">oa_exchange_item</span>, <span class="docutils literal">sa_exchange_item</span></p></td>
-<td><p><span class="docutils literal">kind</span>: Information, Material, Energy; <span class="docutils literal">mechanism</span>: ExchangeMechanism; <span class="docutils literal">supertype</span>: item ref?</p></td>
-<td><p>Information; Unspecified; none</p></td>
+<td><p><span class="docutils literal">kind</span>: Information, Material, Energy, Event</p></td>
+<td><p>Information</p></td>
 </tr>
 <tr><td><p><span class="docutils literal">oa_data_type</span>, <span class="docutils literal">sa_data_type</span></p></td>
-<td><p><span class="docutils literal">definition</span>: DataTypeDefinition; <span class="docutils literal">default</span>: DataValue?; <span class="docutils literal">unit</span>: string</p></td>
-<td><p>String with minimum_length 0 / maximum_length none; none; <span class="docutils literal">&quot;&quot;</span></p></td>
+<td><p><span class="docutils literal">definition</span>: Boolean, Integer, Real, String, Record, or Enumeration constructor</p></td>
+<td><p>String</p></td>
 </tr>
 <tr><td><p><span class="docutils literal">oa_data_field</span>, <span class="docutils literal">sa_data_field</span></p></td>
-<td><p><span class="docutils literal">type_ref</span>; <span class="docutils literal">minimum</span>: u32; <span class="docutils literal">maximum</span>: optional u32; <span class="docutils literal">unit</span>: string; <span class="docutils literal">direction</span>: ParameterDirection; <span class="docutils literal">storage</span>: FieldStorage; <span class="docutils literal">default</span>: DataValue list?</p></td>
-<td><p>String; 1; 1; <span class="docutils literal">&quot;&quot;</span>; Unspecified; Value; none</p></td>
+<td><p><span class="docutils literal">type_ref</span>; <span class="docutils literal">minimum</span>: u32; <span class="docutils literal">maximum</span>: optional u32; <span class="docutils literal">unit</span>: string</p></td>
+<td><p>String; 1; 1; <span class="docutils literal">&quot;&quot;</span></p></td>
 </tr>
 <tr><td><p><span class="docutils literal">oa_interface</span>, <span class="docutils literal">sa_interface</span></p></td>
-<td><p><span class="docutils literal">supertype</span>: interface ref?</p></td>
-<td><p>none; membership is an identified interface_item_allocation relation</p></td>
+<td><p><span class="docutils literal">items</span>: exchange-item refs</p></td>
+<td><p><span class="docutils literal">[]</span></p></td>
 </tr>
 <tr><td><p><span class="docutils literal">oa_port</span>, <span class="docutils literal">sa_port</span></p></td>
 <td><p><span class="docutils literal">contract</span>: required PortContract; <span class="docutils literal">legacy</span>: optional LegacyPortContract</p></td>
@@ -884,14 +883,6 @@ references. Their kind is the declaration keyword:</p>
 <td><p>Same-layer participant → leaf activity/function</p></td>
 <td><p>None</p></td>
 </tr>
-<tr><td><p><span class="docutils literal">interface_item_allocation</span></p></td>
-<td><p>Same-layer Interface → ExchangeItem</p></td>
-<td><p><span class="docutils literal">order</span> u32 / 0; <span class="docutils literal">transmission</span> TransmissionProtocol / Unspecified; <span class="docutils literal">acquisition</span> AcquisitionProtocol / Unspecified</p></td>
-</tr>
-<tr><td><p><span class="docutils literal">data_association</span></p></td>
-<td><p>Same-layer Record DataType → Record DataType</p></td>
-<td><p><span class="docutils literal">source_role</span>, <span class="docutils literal">target_role</span> / &quot;&quot;; <span class="docutils literal">source_minimum</span>, <span class="docutils literal">target_minimum</span> / 0; <span class="docutils literal">source_maximum</span>, <span class="docutils literal">target_maximum</span> / none; <span class="docutils literal">source_navigable</span>, <span class="docutils literal">target_navigable</span> / false</p></td>
-</tr>
 <tr><td><p><span class="docutils literal">interaction</span></p></td>
 <td><p>OA activity → OA activity</p></td>
 <td><p><span class="docutils literal">items</span> refs / []</p></td>
@@ -972,8 +963,7 @@ references. Their kind is the declaration keyword:</p>
 </table>
 <p>Relation endpoints and carried ExchangeItems stay in the same layer. Parallel
 exchanges with distinct identities are permitted. Self-relations are invalid
-except for a state transition that returns to its source state or an explicit
-DataAssociation between two ends of the same Record type.</p>
+except for a state transition that returns to its source state.</p>
 <p>Direct Allocation has at most one performer per leaf. Role sharing is a
 different relationship: several OA participants can realize a Role. A direct
 allocation inconsistent with its role's realized performers produces an
@@ -986,10 +976,9 @@ declares <span class="docutils literal">outgoing_items</span>; <span class="docu
 The lists contain distinct same-layer ExchangeItem references. A functional
 exchange MUST reference output/input ports owned by its respective functions,
 and each carried item MUST fit both declarations. Empty declarations accept
-no items. A carried item satisfies an identical declaration or a declaration
-of one of its explicit base items. A base item does not satisfy a more
-specialized declaration; names imply no compatibility. Port declarations
-remain independent of incident exchanges after creation.</p>
+no items. Item compatibility is identity equality; future specialization is
+not inferred from names. Port declarations remain independent of incident
+exchanges after creation.</p>
 <p>A <span class="docutils literal">Component</span> contract belongs to an SA System or SystemActor and stores
 <span class="docutils literal">kind</span> (Standard or Flow) and <span class="docutils literal">orientation</span> (Unset, In, Out, InOut).
 Standard requires Unset. Flow Unset is an incomplete draft, not InOut. Typed
@@ -1017,18 +1006,17 @@ pickers do not offer it. Resolution to a typed SA contract retains this record
 without treating it as another active constraint. OA generic ports remain
 Legacy; OA Interactions stay activity-to-activity without function ports.
 Deleting a referenced legacy interface clears that optional live reference.</p>
-<p>A current-source functional exchange MUST specify both port aliases; the parser does
+<p>A source-3 functional exchange MUST specify both port aliases; the parser does
 not create endpoints. Graphical/command FE creation plans ports atomically,
 using unique compatible typed-port reuse or deterministic new endpoints.
 Port deletion cascades to incident FEs; FE deletion retains independent ports.</p>
 <p>For example:</p>
-<pre class="literal-block">arcadia 5;
+<pre class="literal-block">arcadia 3;
 project ports_example &quot;Typed function contract&quot; {
     sa_function send &quot;Send&quot; {}
     sa_function receive &quot;Receive&quot; {}
     sa_exchange_item payload &quot;Payload&quot; {}
-    sa_interface old_service &quot;Preserved service&quot; {}
-    interface_item_allocation service_payload &quot;Service payload&quot; { source &#64;old_service; target &#64;payload; }
+    sa_interface old_service &quot;Preserved service&quot; { items [&#64;payload]; }
     sa_port output &quot;Output&quot; {
         parent &#64;send;
         contract { FunctionOutput { outgoing_items [&#64;payload]; }; };
@@ -1044,8 +1032,7 @@ project ports_example &quot;Typed function contract&quot; {
     sa_port preserved &quot;Unresolved original&quot; {
         parent &#64;send; contract Legacy;
         legacy { direction InOut; interface &#64;old_service; };
-    }
-}</pre>
+    }</pre>
 <p>An exclusive region has at most one initial state. Missing initial state is
 a completeness warning. Initial states have no incoming transitions and at
 most one outgoing transition; their outgoing transition has no trigger/guard.
@@ -1138,19 +1125,11 @@ local to its sender lifeline, has no global exchange or values, and has either
 no receiver or the same receiver as sender. Its nonempty expression describes
 the delay/deadline; an empty expression warns. Conditions and expressions are
 stored engineering annotations, not an executable simulation language.</p>
-<p>Each MessageValue is <span class="docutils literal">{ path [&#64;parameter]; field &#64;data_field; expression &quot;value expression&quot;; }</span>.
-Its identity is the pair (path, field), so two uses of one Record can have
-different values for the same terminal field. Path contains enclosing DataField
-references, excluding the terminal field; direct parameters use <span class="docutils literal">[]</span>. Every
-hop MUST follow Value storage through a named Record's effective fields. Reference
-storage stops traversal. Operation Call accepts In/InOut and Reply accepts
-Out/InOut/Return, interpreted from the provider's perspective. Nested field paths
-inherit their direct parameter's direction. Unspecified direction warns.
-At most one annotation for a pair is allowed. Omitted path defaults to <span class="docutils literal">[]</span>;
-an ambiguous preserved legacy nested annotation warns <span class="docutils literal">message_value_ambiguous_path</span>
-until an explicit path is selected. New graphical choices always identify a path.
-Values never overwrite types or items. Expression text is descriptive, preserved
-exactly and not evaluated; an empty expression warns.</p>
+<p>Each MessageValue is <span class="docutils literal">{ field &#64;data_field; expression &quot;value expression&quot;; }</span>.
+The field MUST be a DataField carried by the message exchange, including fields
+inside named nested records. At most one annotation for a given field is
+allowed in one message. Values do not overwrite the referenced type or global
+exchange item. Expression text is preserved exactly; an empty expression warns.</p>
 <p>ScenarioUse references an existing same-layer scenario and maps its lifelines
 with <span class="docutils literal">bindings [ { referenced &#64;callee_line; local &#64;caller_line; } ];</span>.
 Each binding is one-to-one and references a direct lifeline of the appropriate
@@ -1301,137 +1280,6 @@ DeepHistory remembers nested configuration. Fallback applies when no resumable
 history exists. History is per Region, including top-level Regions in this
 Studio profile; no running history state is persisted or synthesized.</p>
 </section>
-<section id="data-contracts-specialization-and-interface-allocation">
-<h3>4.5. Data contracts, specialization and interface allocation</h3>
-<p>ExchangeItem <span class="docutils literal">kind</span> describes nature: Information, Material or Energy.
-<span class="docutils literal">mechanism</span> is Unspecified, Flow, Event, Operation or SharedData. Unknown
-mechanisms remain explicit Unspecified drafts with a warning. Material/Energy
-with Event/Operation/SharedData warns for engineering review; it is not silently
-reclassified. Empty Event notifications and void Operations are valid. An empty
-carried/allocated Flow, SharedData or Unspecified item warns.</p>
-<p>An Operation's directly owned DataFields are parameters. <span class="docutils literal">direction</span> is
-Unspecified, In, Out, InOut or Return, from the provider's perspective. At most
-one effective parameter is Return. Unspecified parameters warn; non-operation
-fields MUST use Unspecified. Nested record fields inherit direction from their
-direct parameter when used in message paths, rather than storing context on a
-shared type. <span class="docutils literal">storage</span> is Value or Reference. Reference requires a named Record,
-has no explicit default, and does not convey ownership or deletion of the type.</p>
-<p>DataTypeDefinition has exactly the following constructors:</p>
-<table>
-<caption>Reusable definitions</caption>
-<thead>
-<tr><th class="head"><p>Constructor</p></th>
-<th class="head"><p>Required fields</p></th>
-</tr>
-</thead>
-<tbody>
-<tr><td><p>Boolean</p></td>
-<td><p>None</p></td>
-</tr>
-<tr><td><p>Integer</p></td>
-<td><p><span class="docutils literal">minimum</span>, <span class="docutils literal">maximum</span>: optional signed 64-bit integers</p></td>
-</tr>
-<tr><td><p>Real</p></td>
-<td><p><span class="docutils literal">minimum</span>, <span class="docutils literal">maximum</span>: optional finite IEEE-754 binary64 values</p></td>
-</tr>
-<tr><td><p>String</p></td>
-<td><p><span class="docutils literal">minimum_length</span>: u32; <span class="docutils literal">maximum_length</span>: optional u32</p></td>
-</tr>
-<tr><td><p>Enumeration</p></td>
-<td><p><span class="docutils literal">literals</span>: unique nonempty, case-sensitive strings</p></td>
-</tr>
-<tr><td><p>Record</p></td>
-<td><p><span class="docutils literal">supertype</span>: same-layer Record ref?</p></td>
-</tr>
-</tbody>
-</table>
-<p>Bounds are inclusive and ordered; an absent bound means unbounded within the
-represented numeric domain. Integer comparisons MUST NOT convert to binary64.
-NaN, infinities, overflow and reversed bounds reject. String length counts Unicode
-scalar values, not UTF-8 bytes or grapheme clusters. Enum defaults match exact
-literals. Empty enum definitions remain incomplete drafts with a warning.</p>
-<p>DataValue is a tagged scalar: <span class="docutils literal">{ Boolean true; }</span>, <span class="docutils literal">{ Integer 42; }</span>,
-<span class="docutils literal">{ Real 1.5; }</span>, <span class="docutils literal">{ String &quot;value&quot;; }</span> or <span class="docutils literal">{ Enumeration &quot;Ready&quot;; }</span>.
-There is no implicit numeric or string coercion. A type default is one compatible
-scalar within its bounds. Record type defaults and record/object instance literals
-are unsupported. A field default is absent (<span class="docutils literal">none</span>) or a list of compatible
-scalars with length inside its multiplicity. <span class="docutils literal">[]</span> explicitly supplies an empty
-collection and requires minimum 0, including Value Record fields; a nonempty
-Record literal rejects. Reference fields MUST use <span class="docutils literal">none</span>. A one-valued scalar
-field uses a one-value list. A named type default supplies an individual element's
-default, not a collection or an implicit instance of a mandatory field.</p>
-<p>Numeric types may carry unit text. Empty field units inherit the named type unit;
-an explicit different unit warns when that type has a unit. Units on nonnumeric
-fields/types warn and remain preserved. Unit strings never convert values or
-establish dimensional compatibility. Expressions are not executed.</p>
-<p>Record, ExchangeItem and Interface each permit one same-family, same-layer
-supertype. Specialization is acyclic and separate from containment. Effective
-fields are base fields followed by local fields, preserving original field UUIDs
-and owners. Local names MUST NOT shadow inherited names. Item specialization
-preserves base nature and any specified mechanism; an Unspecified base mechanism
-may be refined. Deleting a derived record never deletes its base. Mandatory
-Value-field cycles warn <span class="docutils literal">record_no_finite_value</span>; optional or Reference cycles
-are valid without that warning. Traversal is cycle guarded and bounded; a payload
-path budget failure is an explicit diagnostic, not silent truncation.</p>
-<p>InterfaceItemAllocation is an ordinary identified relation from Interface to
-ExchangeItem. It stores <span class="docutils literal">order</span> and independent transmission/acquisition
-protocols. Transmission is Unspecified, Synchronous, Asynchronous, Unicast,
-Multicast or Broadcast; acquisition is Unspecified, Read or Accept. No protocol
-combination is inferred from mechanism. Effective allocations are base-first,
-then local ordered by (order, alias, UUID). A local item already allocated locally
-or inherited is an error. Removing an allocation keeps its item and other
-allocations; if live boundary compatibility would break, the transaction MUST
-repair the affected contract explicitly or reject atomically. Artifacts can
-reference the allocation identity independently of the global item.</p>
-<p>An exchange carrying a specialized item satisfies a declaration of its base,
-never the reverse. Standard provided/required compatibility uses explicit
-interface ancestry. Identity/ancestry, not matching names, defines conformance.
-The current typed function/component port contracts remain unchanged.</p>
-<p>DataAssociation connects Record types without adding fields or transitively
-carrying payload. Each named end has role, multiplicity and navigability. Source
-multiplicity counts source instances per target instance and vice versa; it is
-not a count of model elements. An end's navigable flag permits navigation toward
-that end. Self-associations are valid; if both ends are navigable they require
-distinct nonempty roles. Empty roles and duplicate role contracts warn, whereas
-invalid ranges reject. Composition/shared aggregation, multiple inheritance,
-redefinition, instance literals and arbitrary-precision decimal arithmetic are
-outside this bounded contract.</p>
-<p>This complete data contract example is also exercised through the REST API:</p>
-<pre class="code text literal-block"><code>arcadia 5;
-project engineering_data &quot;Engineering data&quot; {
-    sa_data_type voltage &quot;Voltage&quot; {
-        definition { Real { minimum 0.0; maximum 48.0; }; };
-        default { Real 24.0; }; unit &quot;V&quot;;
-    }
-    sa_data_type coordinate &quot;Coordinate&quot; {
-        definition { Record { supertype none; }; };
-        sa_data_field latitude &quot;Latitude&quot; { type_ref Real; }
-    }
-    sa_data_type located &quot;Located asset&quot; {
-        definition { Record { supertype &#64;coordinate; }; };
-        sa_data_field supply &quot;Supply&quot; { type_ref { Named &#64;voltage; }; }
-    }
-    sa_exchange_item navigate &quot;Navigate&quot; {
-        mechanism Operation;
-        sa_data_field origin &quot;Origin&quot; { type_ref { Named &#64;coordinate; }; direction In; }
-        sa_data_field destination &quot;Destination&quot; { type_ref { Named &#64;coordinate; }; direction In; }
-        sa_data_field accepted &quot;Accepted&quot; { type_ref Boolean; direction Return; }
-    }
-    sa_interface navigation &quot;Navigation&quot; {}
-    sa_interface monitoring &quot;Monitoring&quot; {}
-    interface_item_allocation nav_operation &quot;Navigation operation&quot; {
-        source &#64;navigation; target &#64;navigate; transmission Synchronous; acquisition Accept;
-    }
-    interface_item_allocation monitor_operation &quot;Monitoring operation&quot; {
-        source &#64;monitoring; target &#64;navigate; transmission Asynchronous; acquisition Read;
-    }
-    data_association location_link &quot;Location relationship&quot; {
-        source &#64;coordinate; target &#64;located;
-        source_role &quot;location&quot;; target_role &quot;assets&quot;;
-        source_maximum 1;
-    }
-}</code></pre>
-</section>
 </section>
 <section id="diagrams-artifacts-and-cross-layer-traceability">
 <h2>5. Diagrams, artifacts, and cross-layer traceability</h2>
@@ -1460,7 +1308,7 @@ remove or relocate incompatible placements in the same transaction. Context
 errors use <span class="docutils literal">state_diagram_context</span>; incompatible placements use
 <span class="docutils literal">state_diagram_member</span>. Neither case silently hides invalid members.</p>
 <p>This complete source example places one state from an existing machine:</p>
-<pre class="code text literal-block"><code>arcadia 5;
+<pre class="code text literal-block"><code>arcadia 3;
 project operating &quot;Operating modes&quot; {
     oa_entity crew &quot;Crew&quot; {}
     oa_state_machine modes &quot;Modes&quot; { parent &#64;crew; }
@@ -1627,11 +1475,9 @@ are invalid.</p>
 </tr>
 </tbody>
 </table>
-<p>A nonempty baseline retains the required prose records <span class="docutils literal">oa { name <span class="pre">&quot;...&quot;;</span> description <span class="pre">&quot;...&quot;;</span> }; sa { name <span class="pre">&quot;...&quot;;</span> description <span class="pre">&quot;...&quot;;</span> };</span> and optionally
-<span class="docutils literal">semantic</span> (default none), defined below. The original prose records and typed
-semantic facts are distinct review histories. Importing an older prose baseline
-MUST NOT fabricate semantic acknowledgements. Neither history is a full model
-snapshot, structural synchronization, or a lossless inverse transition.
+<p>A nonempty baseline is <span class="docutils literal">{ oa { name <span class="pre">&quot;...&quot;;</span> description <span class="pre">&quot;...&quot;;</span> }; sa { name <span class="pre">&quot;...&quot;;</span> description <span class="pre">&quot;...&quot;;</span> }; }</span>. It records last-reviewed names
+and descriptions, not a full structural snapshot. Implementations MUST NOT
+present it as structural synchronization or a lossless inverse transition.
 Explicit counterpart creation, linking, comparison, and reviewed property
 update may start in either layer. Ordinary edits MUST NOT automatically
 overwrite the counterpart. Deletion MUST NOT silently cascade across layers.</p>
@@ -1643,358 +1489,15 @@ instead of silently creating a different mapping. Required/subtree process and
 chain transitions include their contextual links, owned contributions and
 referenced dependencies. New process/chain contribution mappings use Sequence
 traces; older Scenario-kind occurrence mappings remain accepted. The current
-prose baseline alone does not reconcile later topology changes.</p>
-<p>In the prose-only workflow, name and description are compared independently
-against each endpoint's last-reviewed baseline. An unchanged source MUST NOT overwrite an accepted
+name/description baseline does not reconcile later topology changes.</p>
+<p>Name and description are compared independently against each endpoint's
+last-reviewed baseline. An unchanged source MUST NOT overwrite an accepted
 different target value. A source-only change proposes an update; different
 changes on both sides require an explicit decision to take the source, keep
 the target, or enter a merged value. An explicit decision records both current
 values as reviewed, even when they differ. A target-only edit is preserved
 without advancing that field's baseline, so it remains eligible to propagate
 in the reverse direction. Equal current values can be recorded as converged.</p>
-<section id="typed-semantic-review-facts">
-<h3>5.1. Typed semantic review facts</h3>
-<p><span class="docutils literal">baseline.semantic</span> is either none or <span class="docutils literal">{ facets [facet, <span class="pre">...];</span> }</span>.
-Each facet is a closed, self-tagged typed record, not a free-form path/value
-entry. List position does not identify a facet. A scalar fact is exactly
-<span class="docutils literal">{ Family { Leaf { oa observation; sa observation; }; }; }</span>. Each observation
-is either <span class="docutils literal">NotApplicable</span> or <span class="docutils literal">{ Value value; }</span>, with the value type fixed
-by Family/Leaf. Both sides are always canonical OA/SA, even during reverse review.</p>
-<p><span class="docutils literal">{ Value none; }</span> means an applicable optional field was absent;
-<span class="docutils literal">NotApplicable</span> means the field's branch or record was not applicable.
-An absent facet means Unreviewed. These meanings MUST NOT be conflated. Each
-side is compared with its own last-reviewed value; deliberately unequal values
-can be reviewed and unchanged. Reviewing one minimum does not acknowledge a
-maximum, unit, default, header or referenced type definition.</p>
-<p>Historical facts are independently acknowledged observations. They need not
-compose one coherent former model: two bounds can have different review times.
-They MAY outlive the endpoint's former record family, constructor and referenced
-objects. Historical admission checks their closed payload types, finite values,
-text, keys and uniqueness; it MUST NOT require a currently existing referenced
-object or current family applicability. In contrast, a new graphical or planned
-resolution MUST address the appropriate current record family and have at least
-one currently applicable side. Both-side NotApplicable facts are invalid persisted
-acknowledgements. A grouped constructor decision retires such obsolete branch facts.</p>
-<p>The following table is the exhaustive scalar catalog. <span class="docutils literal">T?</span> denotes an optional
-T, <span class="docutils literal">T[]</span> a list, and <span class="docutils literal">Id</span> a historical UUID. Existing enum and typed payload
-definitions in sections 3–4 apply. Every listed leaf wraps <span class="docutils literal">{ oa <span class="pre">...;</span> sa <span class="pre">...;</span> }</span>.</p>
-<table>
-<caption>Closed scalar semantic facets</caption>
-<colgroup>
-<col style="width: 15.0%" />
-<col style="width: 85.0%" />
-</colgroup>
-<thead>
-<tr><th class="head"><p>Family</p></th>
-<th class="head"><p>Leaves and observation value types</p></th>
-</tr>
-</thead>
-<tbody>
-<tr><td><p>Header</p></td>
-<td><p>Name, Description: string; Parent: Id?</p></td>
-</tr>
-<tr><td><p>ExchangeItem</p></td>
-<td><p>Nature: ExchangeItemKind; Mechanism: ExchangeMechanism; Supertype: Id?</p></td>
-</tr>
-<tr><td><p>Interface</p></td>
-<td><p>Supertype: Id?</p></td>
-</tr>
-<tr><td><p>Data</p></td>
-<td><p>Constructor: DataConstructor; IntegerMinimum, IntegerMaximum: i64?; RealMinimum, RealMaximum: finite f64?; StringMinimumLength: u32; StringMaximumLength: u32?; RecordSupertype: Id?; Default: DataValue?; Unit: string</p></td>
-</tr>
-<tr><td><p>Field</p></td>
-<td><p>Type: TypeRef; Minimum: u32; Maximum: u32?; Unit: string; Direction: ParameterDirection; Storage: FieldStorage; Default: DataValue[]?</p></td>
-</tr>
-<tr><td><p>Port</p></td>
-<td><p>Constructor: PortConstructor; ComponentKind: ComponentPortKind; Orientation: ComponentPortOrientation; LegacyDirection: PortDirection; LegacyInterface: Id?</p></td>
-</tr>
-<tr><td><p>Scenario</p></td>
-<td><p>Viewpoint: ScenarioViewpoint; Context: Id?; Precondition, Postcondition: string</p></td>
-</tr>
-<tr><td><p>Lifeline</p></td>
-<td><p>Represented: Id?</p></td>
-</tr>
-<tr><td><p>Occurrence</p></td>
-<td><p>Constructor: OccurrenceConstructor; Precondition, Postcondition: string; Exchange, Sender, Receiver: Id?; MessageKind: MessageConstructor; TimerExpression: string; ReplyTo, Action, ActionLifeline: Id?; ControlKind: ControlKind; Sequence, Scenario, State, StateLifeline: Id?; FragmentOperator: FragmentOperator; BranchGuard: string</p></td>
-</tr>
-<tr><td><p>Event</p></td>
-<td><p>Constructor: EventConstructor; TimeKind: TimeEventKind; TimeExpression, ChangeExpression: string</p></td>
-</tr>
-<tr><td><p>State</p></td>
-<td><p>Kind: StateKind; Entry, Exit, DoActivity: string</p></td>
-</tr>
-<tr><td><p>Constraint</p></td>
-<td><p>Expression: string</p></td>
-</tr>
-<tr><td><p>Relation</p></td>
-<td><p>Source, Target: Id; AllocationOrder: u32; Transmission: TransmissionProtocol; Acquisition: AcquisitionProtocol; SourceRole, TargetRole: string; SourceMinimum, TargetMinimum: u32; SourceMaximum, TargetMaximum: u32?; SourceNavigable, TargetNavigable: bool; SourcePort, TargetPort: Id; Oriented: bool; ExtendCondition, SequenceGuard: string; TransitionKind: TransitionKind; Trigger, Guard, Effect: string; StateActionPhase: StateActionKind</p></td>
-</tr>
-</tbody>
-</table>
-</section>
-<section id="members-rows-order-and-attached-records">
-<h3>5.2. Members, rows, order, and attached records</h3>
-<p>The remaining facet forms are closed records. <span class="docutils literal">keys</span> means <span class="docutils literal">{ oa <span class="pre">key-or-none;</span> sa <span class="pre">key-or-none;</span> }</span>; at least one key MUST be present. <span class="docutils literal">review</span> means the same
-required OA/SA observation pair used above.</p>
-<table>
-<caption>Closed keyed and ordered semantic facets</caption>
-<colgroup>
-<col style="width: 17.0%" />
-<col style="width: 45.0%" />
-<col style="width: 38.0%" />
-</colgroup>
-<thead>
-<tr><th class="head"><p>Outer tag</p></th>
-<th class="head"><p>Required fields</p></th>
-<th class="head"><p>Key / reviewed value type</p></th>
-</tr>
-</thead>
-<tbody>
-<tr><td><p>Member</p></td>
-<td><p>collection; keys; review</p></td>
-<td><p>Id / bool</p></td>
-</tr>
-<tr><td><p>Order</p></td>
-<td><p>collection; review</p></td>
-<td><p>No keys / Id[]</p></td>
-</tr>
-<tr><td><p>Literal</p></td>
-<td><p>keys; review</p></td>
-<td><p>Exact case-sensitive string / bool</p></td>
-</tr>
-<tr><td><p>Annotation</p></td>
-<td><p>keys; review</p></td>
-<td><p><span class="docutils literal">{ path <span class="pre">Id[];</span> field Id; }</span> / MessageValue?</p></td>
-</tr>
-<tr><td><p>Binding</p></td>
-<td><p>keys; review</p></td>
-<td><p>Referenced lifeline Id / LifelineBinding?</p></td>
-</tr>
-<tr><td><p>Child</p></td>
-<td><p>keys; review</p></td>
-<td><p>Direct child Id / bool</p></td>
-</tr>
-<tr><td><p>Incident</p></td>
-<td><p>keys; end; review</p></td>
-<td><p>Relation Id, end Source or Target / bool</p></td>
-</tr>
-<tr><td><p>Artifact</p></td>
-<td><p>keys; review</p></td>
-<td><p>Artifact Id / nested artifact facet below</p></td>
-</tr>
-</tbody>
-</table>
-<p>Member.collection is exactly Steps, FragmentBranches, FunctionInputItems,
-FunctionOutputItems, SignalItems, ExchangeItems, TransitionTriggers,
-TransitionEffects or Constrained. Order.collection is exactly Steps or
-FragmentBranches. Order is independent of membership and MUST contain each
-surviving member exactly once when applied. Membership Keep does not refresh
-order history. An automatic insertion requires a unique unchanged mapped anchor;
-ambiguous insertion or conflicting inferred orders requires an explicit final
-target order. Independent removals can filter the order to surviving members.</p>
-<p>Annotation identity is the complete <span class="docutils literal">(path, field)</span> pair. Its MessageValue
-payload contains <span class="docutils literal">path</span>, <span class="docutils literal">field</span> and <span class="docutils literal">expression</span>; the payload key MUST
-match its side's selector key. Binding payloads contain <span class="docutils literal">referenced</span> and
-<span class="docutils literal">local</span>; <span class="docutils literal">referenced</span> MUST match that side's key. Each row is one atomic
-fact. Changing its key is an explicit old-row removal/new-row addition, not an
-expression-only edit. Defaults containing repeated DataValues are atomic optional
-vectors because those values have no stable member identity.</p>
-<p>Artifact.review is <span class="docutils literal">{ Leaf { oa observation; sa observation; }; }</span> where Leaf
-is Presence: bool; Name, Description or Uri: string; Owner: Id;
-Relation: ArtifactRelation; Revision or Fragment: string?. Metadata decisions
-are authorized on the artifact's attachment in the initial project. An explicit
-Owner candidate may move a target-only link and record its resulting Owner and
-other selected metadata. Presence remains relative to the trace owner. Subsequent
-metadata decisions require its new owner trace; historical facts remain attached
-to the trace that recorded them. No review fetches artifact content.</p>
-<p>Duplicate scalar selectors and keyed selectors that occupy the same OA slot or
-the same SA slot are invalid, even when the other side's key differs. Historical
-order vectors MUST NOT repeat an Id. Review history has a limit of 16384 facets,
-128 Ids in an annotation path, 1000000 bytes per string, and 1000000 traversal
-steps per baseline. Exceeding these implementation work limits produces a
-diagnostic; truncation MUST NOT be accepted as a complete review.</p>
-</section>
-<section id="constructor-groups-and-decisions">
-<h3>5.3. Constructor groups and decisions</h3>
-<p>Persisted constructors are discriminator words only:</p>
-<ul class="simple">
-<li><p>DataConstructor: Boolean, Integer, Real, String, Enumeration, Record.</p></li>
-<li><p>PortConstructor: FunctionInput, FunctionOutput, Component, Legacy.</p></li>
-<li><p>OccurrenceConstructor: Exchange, Action, Control, SequenceReference,
-ScenarioUse, State, Fragment, Branch.</p></li>
-<li><p>EventConstructor: Signal, Time, Change.</p></li>
-<li><p>MessageConstructor: Asynchronous, Call, Reply, Create, Delete, Timer.</p></li>
-</ul>
-<p>When a discriminator has no prior fact after explicit resets, both current sides
-are applicable and equal, and the proposed target discriminator is unchanged,
-KeepTarget, TakeSource or Candidate acknowledges only that discriminator.
-It MUST NOT copy a constructor payload, acknowledge unselected descendants or
-retire branch history. Descendant facets may be independently selected in the
-same review; their decisions retain their own scopes and final-value audits.
-Candidate records still MUST NOT change an unselected facet. Missing applicability
-on either side does not qualify as an equal discriminator acknowledgement.</p>
-<p>A grouped constructor resolution uses a transient typed target record, then
-records the discriminator and each acknowledged descendant as separate facts.
-It MUST NOT persist a second whole constructor payload overlapping those leaves.
-Data includes its branch fields, literals and coupled default, but excludes Unit.
-Port includes its contract, Legacy fields and item members. Event includes its
-branch fields and Signal items. Occurrence includes its variant payload, members,
-order, annotations and bindings, but excludes outer Precondition/Postcondition.
-MessageKind includes its discriminator and dependent TimerExpression. State.Kind
-is its own structural facet even though it changes the element's derived kind.
-Other dependent changes caused by preparation remain explicit impacts.</p>
-<p>A grouped constructor Keep requires an actual discriminator proposal or a
-discriminator change since its prior review. Repeating Keep on an already reviewed
-unequal pair MUST NOT acknowledge unrelated bound/default drift. A real target switch may
-reconsider a previously kept difference. When the target already has the proposed
-constructor, reconciliation MUST preserve target-only members rather than replace
-its whole list. Removed branch facts participate in agreement as NotApplicable;
-facts with neither side remaining applicable are retired.</p>
-<p>Semantic review supports these explicit decisions in either direction:</p>
-<ul class="simple">
-<li><p>KeepTarget records the current source and retained target values for only the
-selected facet, or the explicitly displayed constructor group.</p></li>
-<li><p>TakeSource maps the selected source value through the frozen correspondence and
-applies only that facet's delta. Unrelated target edits and target-only collection
-members, rows, children and artifacts remain intact. Removing membership unlinks
-the target member; it does not authorize deleting the target semantic object.</p></li>
-<li><p>Candidate supplies final existing typed Element, Relation or Artifact records.
-Only selected facets may differ from the result. Identity, alias and layer are
-protected. New artifact creation requires a complete candidate and review of
-every introduced metadata facet; removal also reviews the metadata retirement.</p></li>
-</ul>
-<p>Headers have explicit semantic Name/Description facets; the original prose-only
-workflow remains supported with its own baseline. Ordinary source editing can
-explicitly edit a valid baseline; neither baseline format attests that a human
-performed a particular review workflow.
-Decision requests, final candidates and prepared impacts are transient editor/API
-data. Source persists the resulting ordinary model and typed baseline facts;
-it does not persist KeepTarget/TakeSource/Candidate as extra facet fields.</p>
-</section>
-<section id="correspondence-agreement-and-atomic-preparation">
-<h3>5.4. Correspondence, agreement, and atomic preparation</h3>
-<p>Correspondence is an explicit canonical OA-to-SA Id map, including historical
-deleted IDs. Names and aliases MUST NOT guess correspondence. Reverse application
-uses its inverse and rejects ambiguity. Multiple trace kinds for one endpoint
-pair require an explicit trace selection. Changing a keyed pairing requires an
-explicit reset naming the prior selector; old pairs are never silently replaced.
-If a previously paired member or branch disappears on one side, retain its pair
-with the absent/NotApplicable observation, suppressing a redundant one-sided
-projection. A newly appearing pair still requires reset of old one-sided history.</p>
-<p>All selected source proposals use one immutable initial project. Resets precede
-catalog and constructor-scope derivation. Many sources may affect one target only
-when their desired values agree on every actual canonical target slot, including
-removals and members introduced by another proposal. Child membership and the
-actual child's Parent share one slot; incidents share the relation's Source or
-Target endpoint; artifact Presence and Owner share the actual artifact owner slot.
-Conflicting desired values MUST reject independently of request order.</p>
-<p>Materialize the agreed writes once, then audit each desired selected value.
-Prepare one ordinary complete Command batch and compare its actual project with
-the explicitly reviewed candidate. Additional cleanup, such as inherited message
-annotation pruning, is reported as exact object <span class="docutils literal">before</span>/<span class="docutils literal">after</span> typed records
-(or absence for creation/deletion). Every induced impact requires explicit review;
-an accepted impact still MUST NOT contradict a selected Keep/Take. Repeat the
-selected-value audit after preparation. Baseline updates belong to the same atomic
-transaction and source-preserving writeback as model edits.</p>
-<p>A plan's base fingerprint detects a stale model; its prepared fingerprint checks
-candidate consistency. The plan is client-supplied data, not an authenticated
-receipt or proof of its original decisions. Applying it validates the complete
-ordinary candidate and preserves generated identities; it does not re-run its
-request to generate new identities. Hosted clients additionally use the revision
-preconditions defined in <span class="docutils literal">api.rst</span>. Invalid/stale plans or failed source writeback
-leave the accepted model, source, baseline, revision and history unchanged.</p>
-<p>Own drift and linked impacts are separate, with incomplete review explicitly
-visible. Absent facts MUST NOT produce a falsely complete Unchanged rollup.
-Shared data/interface/event definitions are reviewed on their own traces; their
-bounded derived impact walk follows reusable definitions and interface allocations,
-not arbitrary architectural neighborhoods, and does not copy them into every
-referrer's baseline. Its limits are 4096 objects per side and 32768 edges; exhaustion
-is a diagnostic. Successful review remains one undoable transaction. Replanning
-unchanged, already acknowledged leaf facts is a no-op only while their requests
-remain applicable. A completed constructor switch or first acknowledgement of an
-equal discriminator MUST be removed from subsequent requests; repeating it when
-no switch remains is rejected. After an artifact moves to another owner,
-metadata review through the old owner's trace is no longer
-applicable and is rejected. An old plan becomes stale after an actual committed
-change.</p>
-</section>
-<section id="source-examples-and-historical-token-rules">
-<h3>5.5. Source examples and historical token rules</h3>
-<p>This valid source records deliberately different constructor/unit observations.
-Its historical integer minimum is absent; the Real side has no integer branch:</p>
-<pre class="literal-block">arcadia 5;
-project reviewed_dimensions &quot;Reviewed dimensions&quot; {
-    oa_data_type oa_dimension &quot;Operational distance&quot; {
-        definition { Integer { minimum 0; maximum 10; }; };
-        unit &quot;m&quot;;
-    }
-    sa_data_type sa_dimension &quot;System distance&quot; {
-        definition { Real { minimum 0; maximum 20; }; };
-        unit &quot;ft&quot;;
-    }
-    trace dimension_review &quot;Dimension review&quot; {
-        oa &#64;oa_dimension;
-        sa &#64;sa_dimension;
-        kind Item;
-        baseline {
-            oa { name &quot;Approved OA name&quot;; description &quot;&quot;; };
-            sa { name &quot;Approved SA name&quot;; description &quot;&quot;; };
-            semantic { facets [
-                { Data { Constructor { oa { Value Integer; }; sa { Value Real; }; }; }; },
-                { Data { IntegerMinimum { oa { Value none; }; sa NotApplicable; }; }; },
-                { Data { Unit { oa { Value &quot;m&quot;; }; sa { Value &quot;ft&quot;; }; }; }; }
-            ]; };
-        };
-    }
-}</pre>
-<p>Historical Id slots require <span class="docutils literal">uuid <span class="pre">&quot;...&quot;</span></span> even if the object still exists.
-Only typed reference slots inside <span class="docutils literal">baseline.semantic</span> accept that atom.
-For example, the following is a valid historical facet value, including a deleted
-named type; <span class="docutils literal">none</span> and bare enum Boolean retain their different typed meanings:</p>
-<pre class="literal-block">{ Field { Type {
-    oa { Value { Named uuid &quot;40000000-0000-4000-8000-000000000090&quot;; }; };
-    sa { Value Boolean; };
-}; }; }</pre>
-<p>A qualified annotation uses the same historical UUID atoms in its key and payload.
-This complete facet records one old row and an applicable absent target row:</p>
-<pre class="literal-block">{ Annotation {
-    keys {
-        oa {
-            path [uuid &quot;40000000-0000-4000-8000-000000000091&quot;];
-            field uuid &quot;40000000-0000-4000-8000-000000000092&quot;;
-        };
-        sa none;
-    };
-    review {
-        oa { Value {
-            path [uuid &quot;40000000-0000-4000-8000-000000000091&quot;];
-            field uuid &quot;40000000-0000-4000-8000-000000000092&quot;;
-            expression &quot;latitude + 1&quot;;
-        }; };
-        sa { Value none; };
-    };
-}; }</pre>
-<p>Historical enums require bare words. Ordinary strings, including UUID-looking
-units, literal keys and expressions, require quoted strings and remain text
-during identity remapping. <span class="docutils literal">&#64;alias</span> is invalid anywhere inside a semantic
-baseline. Live parents, trace endpoints and all other live references still
-require <span class="docutils literal">&#64;alias</span> and MUST NOT accept the historical UUID atom.</p>
-<p>The following substitutions in these examples are invalid:</p>
-<ul class="simple">
-<li><p><span class="docutils literal">oa &quot;NotApplicable&quot;;</span> or <span class="docutils literal">oa { Value &quot;Integer&quot;; };</span> in the Constructor
-review: enum observations require bare words of the correct typed enum.</p></li>
-<li><p><span class="docutils literal">Named <span class="pre">&quot;40000000-0000-4000-8000-000000000090&quot;;</span></span> or <span class="docutils literal">Named &#64;oa_dimension;</span>:
-a historical Id requires the explicit UUID atom.</p></li>
-<li><p><span class="docutils literal">Unit { oa { Value uuid <span class="pre">&quot;40000000-0000-4000-8000-000000000090&quot;;</span> }; ... }</span>:
-a text field cannot hold a reference atom.</p></li>
-<li><p>Repeating the Unit facet, adding an unknown leaf, or supplying a numeric bound
-as a quoted string: closed typed admission rejects the whole candidate.</p></li>
-<li><p>Changing only the annotation payload's field UUID suffix from 092 to 093,
-leaving the key at 092: the row's key and payload disagree.</p></li>
-<li><p>Changing the document header to <span class="docutils literal">arcadia 4;</span> while retaining <span class="docutils literal">semantic</span>:
-the frozen earlier schema does not admit a future baseline shape.</p></li>
-</ul>
-</section>
 </section>
 <section id="text-grammar-and-resolution">
 <h2>6. Text grammar and resolution</h2>
@@ -2014,7 +1517,7 @@ spellings can be used in alias positions because references begin with <span cla
 <span class="docutils literal"><span class="pre">element-kind</span></span> and <span class="docutils literal"><span class="pre">relation-kind</span></span> are exactly the corresponding declaration
 keywords listed above. Typed field
 sets and enum constructors are closed by sections 3–5.</p>
-<pre class="code text literal-block"><code>document    = &quot;arcadia&quot; &quot;5&quot; &quot;;&quot; project
+<pre class="code text literal-block"><code>document    = &quot;arcadia&quot; &quot;3&quot; &quot;;&quot; project
 project     = &quot;project&quot; alias string identity? &quot;{&quot; project-entry* &quot;}&quot;
 project-entry = &quot;description&quot; string &quot;;&quot; | declaration
 declaration = element
@@ -2026,8 +1529,7 @@ element-body = &quot;{&quot; (field-name value &quot;;&quot; | element)* &quot;}
 identity    = &quot;id&quot; uuid-string
 fields      = &quot;{&quot; (field-name value &quot;;&quot;)* &quot;}&quot;
 value       = string | number | &quot;true&quot; | &quot;false&quot; | &quot;none&quot;
-            | enum-word | &quot;&#64;&quot; alias | historical-id | list | fields
-historical-id = &quot;uuid&quot; uuid-string
+            | enum-word | &quot;&#64;&quot; alias | list | fields
 list        = &quot;[&quot; (value (&quot;,&quot; value)*)? &quot;]&quot;</code></pre>
 <p>The project description defaults to empty and may appear once. There is no
 semicolon after a declaration or project closing brace. Every field inside a
@@ -2045,8 +1547,6 @@ bare words cannot substitute for reference-valued fields. Alias resolution
 produces UUID references; the alias itself remains stored on its declaration.
 Changing an alias in source requires updating its uses. Display names never
 resolve references.</p>
-<p><span class="docutils literal"><span class="pre">historical-id</span></span> is context-restricted to the typed semantic baseline reference
-slots in section 5.5; it is not an alternative spelling of a live reference.</p>
 <p>Unknown fields, duplicate fields, incompatible constructor payloads, unsupported
 enum spellings, duplicate aliases/identities, and structural validation errors
 reject the entire candidate. No declaration silently replaces another.
@@ -2054,16 +1554,16 @@ Ordinary string fields require quoted strings and cannot contain an unquoted
 <span class="docutils literal">&#64;alias</span> reference. Enum fields require unquoted named values or their typed
 constructor records. Typed values MUST NOT nest more than 64 levels; malformed
 deeply nested drafts produce a diagnostic instead of exhausting the parser stack.</p>
-<section id="modular-source-projects">
-<h3>6.1. Modular source projects</h3>
+<section id="modular-source3-projects">
+<h3>6.1. Modular source3 projects</h3>
 <p>The pure <span class="docutils literal">source_project</span> core API compiles a virtual source bundle, containing
 <span class="docutils literal">entry</span> and a <span class="docutils literal">files</span> map from logical paths to UTF-8 strings. Its entry is a
-root-level <span class="docutils literal">.arcadia</span> file with the source5 project header above. A project entry
+root-level <span class="docutils literal">.arcadia</span> file with the source3 project header above. A project entry
 MAY also be <span class="docutils literal">include string &quot;;&quot;</span>. An included fragment consists only of ordinary
 declarations and include statements; it MUST NOT contain another version header,
 project wrapper, or project description. Includes MUST occur at document level,
 never inside an element body or typed field value. For example:</p>
-<pre class="literal-block">arcadia 5;
+<pre class="literal-block">arcadia 3;
 project rescue &quot;Rescue&quot; id &quot;00000000-0000-4000-8000-000000000001&quot; {
     description &quot;Operational model&quot;;
     include &quot;oa/participants.arcadia&quot;;
@@ -2121,17 +1621,9 @@ the source index. Columns remain one-based Unicode scalars within the real file;
 spans never refer to concatenated or synthetic source.</p>
 <p>Single-string parse/lint APIs remain filesystem-free and reject include
 statements with an explicit source-bundle requirement. V1/V2 single-file imports
-continue through explicit migration. Modular projects accept source3, source4 and
-source5. Source3 is upgraded as one project, preserving file paths, includes, nested
-ownership and comments through targeted token edits. Generated allocation
-declarations stay in their interface's existing file. Individual include fragments
-are not independently migrated. Missing UUIDs stabilize before migration so new
-allocation identities are deterministic on subsequent compilation.
-An authored source4 bundle upgrades through the strict prose-only baseline
-adapter; after any missing UUID stabilization, the version token alone changes
-to 5. Existing prose, comments, includes and nested ownership remain intact.
-Source5 semantic facet comments follow their closed selector identity through
-row reordering and reidentification; UUID-looking text does not act as an Id.</p>
+continue through their existing migration readers and reports. Modular projects
+require source3; migration is performed before modular export, not independently
+on included fragments. Modular source does not change the semantic JSON schema.</p>
 </section>
 <section id="nested-element-ownership">
 <h3>6.2. Nested element ownership</h3>
@@ -2335,39 +1827,9 @@ explicitly before Apply succeeds.</p>
 <h2>9. Persistence and explicit migration</h2>
 <p>Loading detects JSON from its first non-whitespace <span class="docutils literal">{</span>; other input is parsed
 as Arcadia source regardless of filename. Saving an <span class="docutils literal">.arcadia</span> suffix uses
-the accepted V5 source bundle (<span class="docutils literal">arcadia 5</span>); other suffixes use V5 JSON. Both forms preserve the same
+the accepted V3 source bundle (<span class="docutils literal">arcadia 3</span>); other suffixes use V3 JSON. Both forms preserve the same
 complete model. JSON rejects unknown fields throughout typed payloads,
 duplicate maps, unsupported versions, and structural errors.</p>
-<p>The explicit schema-4 reader retains the exact old Project/Trace/TraceBaseline
-envelope with closed fields. It reuses unchanged typed elements, relations,
-diagrams and artifacts. Version4 prose baselines migrate with semantic none;
-their names/descriptions remain exact even when live endpoint values differ.
-The adapter MUST NOT infer semantic review from live values, and version3/4
-inputs MUST reject semantic baseline fields. The migration report retains the
-original from_schema and current to_schema 5. Reopening a current5 save produces
-no migration report. The real V4 reviewed-prose fixtures remain compatibility input.</p>
-<p>The schema-3 reader freezes the changed data payloads and old constructor catalog;
-schema-4 fields/constructors MUST NOT be silently accepted as schema 3. Existing
-typed PortContract records remain unchanged. Information/Material/Energy retain
-their nature with Unspecified mechanism; old Event becomes Information with Event
-mechanism. Old bounds/defaults/supertypes are absent, String length is 0..unbounded,
-and fields retain type/multiplicity/unit with Unspecified direction, Value storage
-and no explicit default. No physical mechanism or direction is guessed.</p>
-<p>Each old Interface.items entry generates one InterfaceItemAllocation with its
-original zero-based order and Unspecified protocols. UUID v5 uses the project UUID
-namespace and name <span class="docutils literal"><span class="pre">v2-interface-item:&lt;interface-uuid&gt;:&lt;item-uuid&gt;</span></span> consistently
-for schema-2 and schema-3 inputs. Aliases are deterministic and collision-free;
-collision with any existing identity is an error rather than an overwrite. Existing
-interface/item identities remain intact. Old nested message values acquire a path
-only when exactly one valid path exists. Ambiguous paths, including recursive
-reuse, retain the old annotation with a located warning rather than guessing.</p>
-<p>Migration reports additionally contain <span class="docutils literal">semantic_defaults</span> (object, field,
-description), <span class="docutils literal">generated_interface_allocations</span> (id, source, target, alias,
-order) and <span class="docutils literal">unresolved_message_values</span> (occurrence, field, reason). These new
-report arrays default empty when reading older responses. Version 1 normalizes
-through V2, then the typed-port V3 adapter, shared V4 data upgrade and V5 review
-adapter. Original V2 and real V3 fixtures remain unchanged compatibility inputs. Current exports
-always use version 5; reading/migrating alone never saves or changes revisions.</p>
 <p>Native source Save All checks the original contents of observed dependencies
 before staging writes. Existing target files are replaced individually and the
 entry is installed last. A transaction journal records originals and intended
@@ -2391,7 +1853,7 @@ defaults without changing any prior identity, name, reference, order, geometry,
 artifact or trace field. The original V2 golden source/JSON in
 <span class="docutils literal"><span class="pre">crates/oa-core/tests/fixtures</span></span> MUST NOT be regenerated from the newer demo;
 they verify that every old persistent field survives. Canonical output writes
-the added defaults through the explicit schema-3, schema-4 and schema-5 migrations.</p>
+the added defaults through the explicit schema-3 migration.</p>
 <p>The V2 adapter preserves every original identity, alias, prose, parent,
 placement, trace and artifact. Generic ports become Legacy with their original
 direction/interface record. Existing FE endpoint IDs remain unchanged. For
@@ -2408,13 +1870,13 @@ IDs, required resolutions, generated endpoint IDs/aliases/owners, and boundary
 orientation defaults. REST import, replacement, candidate validation and
 project snapshots surface the same report. Opening an old server envelope
 preserves its resource ID/revision and bytes; the next explicit edit writes
-schema 5. Model/source exports contain only the canonical model. Migration
+schema 3. Model/source exports contain only the canonical model. Migration
 reports are transient response metadata, not persisted model facts.</p>
 <p>Admission checks account for generated objects and their references before
-construction. Both the old V2 contract and the resulting V5 graph are
+construction. Both the old V2 contract and the resulting V3 graph are
 validated. Migration itself does not save or increase a stored revision.
 Canonical second saves are stable. V1 normalization produces the frozen V2
-model and then uses these same V2-to-3-to-4-to-5 stages.</p>
+model and then uses this same V2-to-3 stage.</p>
 <p>Save validates a snapshot, writes a sibling temporary file, flushes it, and
 atomically replaces the destination. Failed serialization or validation must
 not truncate a previous file. External concurrent-writer conflict resolution
@@ -2430,20 +1892,20 @@ step becomes a distinct occurrence element owned by its process. Generated
 diagram, node, and occurrence identities use UUID v5 with the old Project ID
 as namespace and deterministic role/index names. If such an identity collides,
 a deterministic suffix is tried. Reimporting the same fully identified V1
-input therefore yields the same V5 result, including repeated occurrences.
+input therefore yields the same V3 result, including repeated occurrences.
 No System or SA content is invented during an OA-only migration.</p>
 <p>V1 source aliases are retained when valid in V2. JSON imports generate the old
 canonical aliases deterministically. Any alias newly reserved in V2 is changed
 by a deterministic suffix; aliases were not persistent V1 semantic data.
 A project alias and aliases for new records are generated without colliding
 with retained aliases. The existing bundled V1 text and JSON migrate to equal
-V5 projects. Future versions remain errors until a separate migration exists.</p>
+V3 projects. Future versions remain errors until a separate migration exists.</p>
 </section>
 <section id="complete-authoring-example">
 <h2>10. Complete authoring example</h2>
 <p>This document intentionally omits IDs for new authoring. Apply and Save write
 the assigned UUIDs explicitly.</p>
-<pre class="code text literal-block"><code>arcadia 5;
+<pre class="code text literal-block"><code>arcadia 3;
 project harbor &quot;Harbor assistance&quot; {
     oa_entity control &quot;Harbor control&quot; {}
     oa_activity assess &quot;Assess assistance&quot; {}
@@ -2480,13 +1942,6 @@ stable aliases, strict syntax/reference failures, Unicode source spans,
 deterministic V1 migration, occurrence identity, coordinate bits, persistence,
 and model-history integration. Core validation and session tests cover domain
 mutation rules; native UI and API verification are separate evidence.</p>
-<p><span class="docutils literal">cargo test <span class="pre">-p</span> <span class="pre">oa-core</span> <span class="pre">--test</span> r3_semantic <span class="pre">--test</span> r3_source <span class="pre">--test</span> r3_migration <span class="pre">--locked</span></span>
-checks the closed facet catalog, partial decisions, constructor scopes, canonical
-agreement, target-only preservation, historic references, exact prepared impacts,
-source/JSON parity, comment ownership and explicit original1–4 migration. The
-source suite includes actual included-file save/reopen and prepared review
-writeback. These checks establish core/source behavior; they do not establish
-graphical or hosted API acceptance by themselves.</p>
 <p>The research record in <span class="docutils literal"><span class="pre">docs/research-v2-semantics.md</span></span> distinguishes method
 requirements from Studio design choices and links to original UI evidence.
 The following sources inform this language without extending its scope:</p>

docs/language.rst

@@ -1,7 +1,7 @@
 Arcadia Studio OA / SA Language and Editing Contract
 ====================================================
 
-:Version: 5
+:Version: 3
 :Status: Normative current implementation contract; first-release integration
 :Core implementation: ``crates/oa-core``
 :Text suffix: ``.arcadia``
@@ -11,16 +11,15 @@ Arcadia Studio OA / SA Language and Editing Contract
 
 This specification defines the shared Operational Analysis (OA) and System
 Analysis (SA) model, its textual language, graphical editing obligations,
-validation, persistence, and explicit migration from versions 1, 2, 3 and 4. MUST, MUST NOT,
+validation, persistence, and explicit migration from versions 1 and 2. MUST, MUST NOT,
 and MAY indicate requirements, prohibitions, and permitted choices.
 
-Schema 5 adds closed typed semantic review facts to trace baselines, including
-historical references that may no longer exist in the live model. It retains
-schema 4 bounded reusable data types, typed defaults, exchange mechanisms,
-qualified values, specialization, interface allocations and associations, and
-schema 3 typed ports and state views. Explicit older readers preserve meanings
-and identities without inventing previously reviewed semantic values.
-This contract does not by itself establish native acceptance or release completion.
+Schema 3 introduces typed function and component ports, required functional
+exchange endpoints, independently oriented boundary exchanges, and explicit
+PortAllocation relations. First-release scenario/state additions remain in
+scope; this schema change does not declare native acceptance or the wider
+release complete. The preserved schema-2 reader validates the original
+contract before migration.
 
 OA describes stakeholders, operational work and needs. SA describes the
 selected system boundary, external actors, functions, services and expected
@@ -41,7 +40,7 @@ Actual verification evidence is separate from this contract.
 2. One authoritative model
 --------------------------
 
-A Project stores ``schema_version`` (5), ``id``, ``alias``, ``name``,
+A Project stores ``schema_version`` (3), ``id``, ``alias``, ``name``,
 ``description``, and maps named ``elements``, ``relations``, ``diagrams``,
 ``artifact_links``, and ``traces``. Each map is keyed by the UUID contained in
 its record. Duplicate map keys and mismatching keys/identities are errors.
@@ -97,17 +96,17 @@ lists all additional fields. ``ref`` means ``@alias``; ``ref?`` also accepts
      - ``steps``: occurrence refs
      - ``[]``
    * - ``oa_exchange_item``, ``sa_exchange_item``
-     - ``kind``: Information, Material, Energy; ``mechanism``: ExchangeMechanism; ``supertype``: item ref?
-     - Information; Unspecified; none
+     - ``kind``: Information, Material, Energy, Event
+     - Information
    * - ``oa_data_type``, ``sa_data_type``
-     - ``definition``: DataTypeDefinition; ``default``: DataValue?; ``unit``: string
-     - String with minimum_length 0 / maximum_length none; none; ``""``
+     - ``definition``: Boolean, Integer, Real, String, Record, or Enumeration constructor
+     - String
    * - ``oa_data_field``, ``sa_data_field``
-     - ``type_ref``; ``minimum``: u32; ``maximum``: optional u32; ``unit``: string; ``direction``: ParameterDirection; ``storage``: FieldStorage; ``default``: DataValue list?
-     - String; 1; 1; ``""``; Unspecified; Value; none
+     - ``type_ref``; ``minimum``: u32; ``maximum``: optional u32; ``unit``: string
+     - String; 1; 1; ``""``
    * - ``oa_interface``, ``sa_interface``
-     - ``supertype``: interface ref?
-     - none; membership is an identified interface_item_allocation relation
+     - ``items``: exchange-item refs
+     - ``[]``
    * - ``oa_port``, ``sa_port``
      - ``contract``: required PortContract; ``legacy``: optional LegacyPortContract
      - No implicit contract; ``legacy`` defaults none. OA admits Legacy only.
@@ -231,12 +230,6 @@ references. Their kind is the declaration keyword:
    * - ``allocation``
      - Same-layer participant → leaf activity/function
      - None
-   * - ``interface_item_allocation``
-     - Same-layer Interface → ExchangeItem
-     - ``order`` u32 / 0; ``transmission`` TransmissionProtocol / Unspecified; ``acquisition`` AcquisitionProtocol / Unspecified
-   * - ``data_association``
-     - Same-layer Record DataType → Record DataType
-     - ``source_role``, ``target_role`` / ""; ``source_minimum``, ``target_minimum`` / 0; ``source_maximum``, ``target_maximum`` / none; ``source_navigable``, ``target_navigable`` / false
    * - ``interaction``
      - OA activity → OA activity
      - ``items`` refs / []
@@ -297,8 +290,7 @@ references. Their kind is the declaration keyword:
 
 Relation endpoints and carried ExchangeItems stay in the same layer. Parallel
 exchanges with distinct identities are permitted. Self-relations are invalid
-except for a state transition that returns to its source state or an explicit
-DataAssociation between two ends of the same Record type.
+except for a state transition that returns to its source state.
 
 Direct Allocation has at most one performer per leaf. Role sharing is a
 different relationship: several OA participants can realize a Role. A direct
@@ -313,10 +305,9 @@ declares ``outgoing_items``; ``FunctionInput`` declares ``incoming_items``.
 The lists contain distinct same-layer ExchangeItem references. A functional
 exchange MUST reference output/input ports owned by its respective functions,
 and each carried item MUST fit both declarations. Empty declarations accept
-no items. A carried item satisfies an identical declaration or a declaration
-of one of its explicit base items. A base item does not satisfy a more
-specialized declaration; names imply no compatibility. Port declarations
-remain independent of incident exchanges after creation.
+no items. Item compatibility is identity equality; future specialization is
+not inferred from names. Port declarations remain independent of incident
+exchanges after creation.
 
 A ``Component`` contract belongs to an SA System or SystemActor and stores
 ``kind`` (Standard or Flow) and ``orientation`` (Unset, In, Out, InOut).
@@ -349,20 +340,19 @@ without treating it as another active constraint. OA generic ports remain
 Legacy; OA Interactions stay activity-to-activity without function ports.
 Deleting a referenced legacy interface clears that optional live reference.
 
-A current-source functional exchange MUST specify both port aliases; the parser does
+A source-3 functional exchange MUST specify both port aliases; the parser does
 not create endpoints. Graphical/command FE creation plans ports atomically,
 using unique compatible typed-port reuse or deterministic new endpoints.
 Port deletion cascades to incident FEs; FE deletion retains independent ports.
 
 For example::
 
-    arcadia 5;
+    arcadia 3;
     project ports_example "Typed function contract" {
         sa_function send "Send" {}
         sa_function receive "Receive" {}
         sa_exchange_item payload "Payload" {}
-        sa_interface old_service "Preserved service" {}
-        interface_item_allocation service_payload "Service payload" { source @old_service; target @payload; }
+        sa_interface old_service "Preserved service" { items [@payload]; }
         sa_port output "Output" {
             parent @send;
             contract { FunctionOutput { outgoing_items [@payload]; }; };
@@ -379,7 +369,6 @@ For example::
             parent @send; contract Legacy;
             legacy { direction InOut; interface @old_service; };
         }
-    }
 
 An exclusive region has at most one initial state. Missing initial state is
 a completeness warning. Initial states have no incoming transitions and at
@@ -485,19 +474,11 @@ no receiver or the same receiver as sender. Its nonempty expression describes
 the delay/deadline; an empty expression warns. Conditions and expressions are
 stored engineering annotations, not an executable simulation language.
 
-Each MessageValue is ``{ path [@parameter]; field @data_field; expression "value expression"; }``.
-Its identity is the pair (path, field), so two uses of one Record can have
-different values for the same terminal field. Path contains enclosing DataField
-references, excluding the terminal field; direct parameters use ``[]``. Every
-hop MUST follow Value storage through a named Record's effective fields. Reference
-storage stops traversal. Operation Call accepts In/InOut and Reply accepts
-Out/InOut/Return, interpreted from the provider's perspective. Nested field paths
-inherit their direct parameter's direction. Unspecified direction warns.
-At most one annotation for a pair is allowed. Omitted path defaults to ``[]``;
-an ambiguous preserved legacy nested annotation warns ``message_value_ambiguous_path``
-until an explicit path is selected. New graphical choices always identify a path.
-Values never overwrite types or items. Expression text is descriptive, preserved
-exactly and not evaluated; an empty expression warns.
+Each MessageValue is ``{ field @data_field; expression "value expression"; }``.
+The field MUST be a DataField carried by the message exchange, including fields
+inside named nested records. At most one annotation for a given field is
+allowed in one message. Values do not overwrite the referenced type or global
+exchange item. Expression text is preserved exactly; an empty expression warns.
 
 ScenarioUse references an existing same-layer scenario and maps its lifelines
 with ``bindings [ { referenced @callee_line; local @caller_line; } ];``.
@@ -639,141 +620,6 @@ DeepHistory remembers nested configuration. Fallback applies when no resumable
 history exists. History is per Region, including top-level Regions in this
 Studio profile; no running history state is persisted or synthesized.
 
-4.5. Data contracts, specialization and interface allocation
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-ExchangeItem ``kind`` describes nature: Information, Material or Energy.
-``mechanism`` is Unspecified, Flow, Event, Operation or SharedData. Unknown
-mechanisms remain explicit Unspecified drafts with a warning. Material/Energy
-with Event/Operation/SharedData warns for engineering review; it is not silently
-reclassified. Empty Event notifications and void Operations are valid. An empty
-carried/allocated Flow, SharedData or Unspecified item warns.
-
-An Operation's directly owned DataFields are parameters. ``direction`` is
-Unspecified, In, Out, InOut or Return, from the provider's perspective. At most
-one effective parameter is Return. Unspecified parameters warn; non-operation
-fields MUST use Unspecified. Nested record fields inherit direction from their
-direct parameter when used in message paths, rather than storing context on a
-shared type. ``storage`` is Value or Reference. Reference requires a named Record,
-has no explicit default, and does not convey ownership or deletion of the type.
-
-DataTypeDefinition has exactly the following constructors:
-
-.. list-table:: Reusable definitions
-   :header-rows: 1
-
-   * - Constructor
-     - Required fields
-   * - Boolean
-     - None
-   * - Integer
-     - ``minimum``, ``maximum``: optional signed 64-bit integers
-   * - Real
-     - ``minimum``, ``maximum``: optional finite IEEE-754 binary64 values
-   * - String
-     - ``minimum_length``: u32; ``maximum_length``: optional u32
-   * - Enumeration
-     - ``literals``: unique nonempty, case-sensitive strings
-   * - Record
-     - ``supertype``: same-layer Record ref?
-
-Bounds are inclusive and ordered; an absent bound means unbounded within the
-represented numeric domain. Integer comparisons MUST NOT convert to binary64.
-NaN, infinities, overflow and reversed bounds reject. String length counts Unicode
-scalar values, not UTF-8 bytes or grapheme clusters. Enum defaults match exact
-literals. Empty enum definitions remain incomplete drafts with a warning.
-
-DataValue is a tagged scalar: ``{ Boolean true; }``, ``{ Integer 42; }``,
-``{ Real 1.5; }``, ``{ String "value"; }`` or ``{ Enumeration "Ready"; }``.
-There is no implicit numeric or string coercion. A type default is one compatible
-scalar within its bounds. Record type defaults and record/object instance literals
-are unsupported. A field default is absent (``none``) or a list of compatible
-scalars with length inside its multiplicity. ``[]`` explicitly supplies an empty
-collection and requires minimum 0, including Value Record fields; a nonempty
-Record literal rejects. Reference fields MUST use ``none``. A one-valued scalar
-field uses a one-value list. A named type default supplies an individual element's
-default, not a collection or an implicit instance of a mandatory field.
-
-Numeric types may carry unit text. Empty field units inherit the named type unit;
-an explicit different unit warns when that type has a unit. Units on nonnumeric
-fields/types warn and remain preserved. Unit strings never convert values or
-establish dimensional compatibility. Expressions are not executed.
-
-Record, ExchangeItem and Interface each permit one same-family, same-layer
-supertype. Specialization is acyclic and separate from containment. Effective
-fields are base fields followed by local fields, preserving original field UUIDs
-and owners. Local names MUST NOT shadow inherited names. Item specialization
-preserves base nature and any specified mechanism; an Unspecified base mechanism
-may be refined. Deleting a derived record never deletes its base. Mandatory
-Value-field cycles warn ``record_no_finite_value``; optional or Reference cycles
-are valid without that warning. Traversal is cycle guarded and bounded; a payload
-path budget failure is an explicit diagnostic, not silent truncation.
-
-InterfaceItemAllocation is an ordinary identified relation from Interface to
-ExchangeItem. It stores ``order`` and independent transmission/acquisition
-protocols. Transmission is Unspecified, Synchronous, Asynchronous, Unicast,
-Multicast or Broadcast; acquisition is Unspecified, Read or Accept. No protocol
-combination is inferred from mechanism. Effective allocations are base-first,
-then local ordered by (order, alias, UUID). A local item already allocated locally
-or inherited is an error. Removing an allocation keeps its item and other
-allocations; if live boundary compatibility would break, the transaction MUST
-repair the affected contract explicitly or reject atomically. Artifacts can
-reference the allocation identity independently of the global item.
-
-An exchange carrying a specialized item satisfies a declaration of its base,
-never the reverse. Standard provided/required compatibility uses explicit
-interface ancestry. Identity/ancestry, not matching names, defines conformance.
-The current typed function/component port contracts remain unchanged.
-
-DataAssociation connects Record types without adding fields or transitively
-carrying payload. Each named end has role, multiplicity and navigability. Source
-multiplicity counts source instances per target instance and vice versa; it is
-not a count of model elements. An end's navigable flag permits navigation toward
-that end. Self-associations are valid; if both ends are navigable they require
-distinct nonempty roles. Empty roles and duplicate role contracts warn, whereas
-invalid ranges reject. Composition/shared aggregation, multiple inheritance,
-redefinition, instance literals and arbitrary-precision decimal arithmetic are
-outside this bounded contract.
-
-This complete data contract example is also exercised through the REST API:
-
-.. code-block:: text
-
-    arcadia 5;
-    project engineering_data "Engineering data" {
-        sa_data_type voltage "Voltage" {
-            definition { Real { minimum 0.0; maximum 48.0; }; };
-            default { Real 24.0; }; unit "V";
-        }
-        sa_data_type coordinate "Coordinate" {
-            definition { Record { supertype none; }; };
-            sa_data_field latitude "Latitude" { type_ref Real; }
-        }
-        sa_data_type located "Located asset" {
-            definition { Record { supertype @coordinate; }; };
-            sa_data_field supply "Supply" { type_ref { Named @voltage; }; }
-        }
-        sa_exchange_item navigate "Navigate" {
-            mechanism Operation;
-            sa_data_field origin "Origin" { type_ref { Named @coordinate; }; direction In; }
-            sa_data_field destination "Destination" { type_ref { Named @coordinate; }; direction In; }
-            sa_data_field accepted "Accepted" { type_ref Boolean; direction Return; }
-        }
-        sa_interface navigation "Navigation" {}
-        sa_interface monitoring "Monitoring" {}
-        interface_item_allocation nav_operation "Navigation operation" {
-            source @navigation; target @navigate; transmission Synchronous; acquisition Accept;
-        }
-        interface_item_allocation monitor_operation "Monitoring operation" {
-            source @monitoring; target @navigate; transmission Asynchronous; acquisition Read;
-        }
-        data_association location_link "Location relationship" {
-            source @coordinate; target @located;
-            source_role "location"; target_role "assets";
-            source_maximum 1;
-        }
-    }
-
 5. Diagrams, artifacts, and cross-layer traceability
 ----------------------------------------------------
 
@@ -808,7 +654,7 @@ This complete source example places one state from an existing machine:
 
 .. code-block:: text
 
-    arcadia 5;
+    arcadia 3;
     project operating "Operating modes" {
         oa_entity crew "Crew" {}
         oa_state_machine modes "Modes" { parent @crew; }
@@ -978,12 +824,10 @@ are invalid.
    * - Manual
      - Engineer-defined relationship between OA/SA elements or relations
 
-A nonempty baseline retains the required prose records ``oa { name "...";
-description "..."; }; sa { name "..."; description "..."; };`` and optionally
-``semantic`` (default none), defined below. The original prose records and typed
-semantic facts are distinct review histories. Importing an older prose baseline
-MUST NOT fabricate semantic acknowledgements. Neither history is a full model
-snapshot, structural synchronization, or a lossless inverse transition.
+A nonempty baseline is ``{ oa { name "..."; description "..."; };
+sa { name "..."; description "..."; }; }``. It records last-reviewed names
+and descriptions, not a full structural snapshot. Implementations MUST NOT
+present it as structural synchronization or a lossless inverse transition.
 Explicit counterpart creation, linking, comparison, and reviewed property
 update may start in either layer. Ordinary edits MUST NOT automatically
 overwrite the counterpart. Deletion MUST NOT silently cascade across layers.
@@ -996,10 +840,10 @@ instead of silently creating a different mapping. Required/subtree process and
 chain transitions include their contextual links, owned contributions and
 referenced dependencies. New process/chain contribution mappings use Sequence
 traces; older Scenario-kind occurrence mappings remain accepted. The current
-prose baseline alone does not reconcile later topology changes.
+name/description baseline does not reconcile later topology changes.
 
-In the prose-only workflow, name and description are compared independently
-against each endpoint's last-reviewed baseline. An unchanged source MUST NOT overwrite an accepted
+Name and description are compared independently against each endpoint's
+last-reviewed baseline. An unchanged source MUST NOT overwrite an accepted
 different target value. A source-only change proposes an update; different
 changes on both sides require an explicit decision to take the source, keep
 the target, or enter a merged value. An explicit decision records both current
@@ -1007,339 +851,6 @@ values as reviewed, even when they differ. A target-only edit is preserved
 without advancing that field's baseline, so it remains eligible to propagate
 in the reverse direction. Equal current values can be recorded as converged.
 
-5.1. Typed semantic review facts
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-``baseline.semantic`` is either none or ``{ facets [facet, ...]; }``.
-Each facet is a closed, self-tagged typed record, not a free-form path/value
-entry. List position does not identify a facet. A scalar fact is exactly
-``{ Family { Leaf { oa observation; sa observation; }; }; }``. Each observation
-is either ``NotApplicable`` or ``{ Value value; }``, with the value type fixed
-by Family/Leaf. Both sides are always canonical OA/SA, even during reverse review.
-
-``{ Value none; }`` means an applicable optional field was absent;
-``NotApplicable`` means the field's branch or record was not applicable.
-An absent facet means Unreviewed. These meanings MUST NOT be conflated. Each
-side is compared with its own last-reviewed value; deliberately unequal values
-can be reviewed and unchanged. Reviewing one minimum does not acknowledge a
-maximum, unit, default, header or referenced type definition.
-
-Historical facts are independently acknowledged observations. They need not
-compose one coherent former model: two bounds can have different review times.
-They MAY outlive the endpoint's former record family, constructor and referenced
-objects. Historical admission checks their closed payload types, finite values,
-text, keys and uniqueness; it MUST NOT require a currently existing referenced
-object or current family applicability. In contrast, a new graphical or planned
-resolution MUST address the appropriate current record family and have at least
-one currently applicable side. Both-side NotApplicable facts are invalid persisted
-acknowledgements. A grouped constructor decision retires such obsolete branch facts.
-
-The following table is the exhaustive scalar catalog. ``T?`` denotes an optional
-T, ``T[]`` a list, and ``Id`` a historical UUID. Existing enum and typed payload
-definitions in sections 3–4 apply. Every listed leaf wraps ``{ oa ...; sa ...; }``.
-
-.. list-table:: Closed scalar semantic facets
-   :header-rows: 1
-   :widths: 15 85
-
-   * - Family
-     - Leaves and observation value types
-   * - Header
-     - Name, Description: string; Parent: Id?
-   * - ExchangeItem
-     - Nature: ExchangeItemKind; Mechanism: ExchangeMechanism; Supertype: Id?
-   * - Interface
-     - Supertype: Id?
-   * - Data
-     - Constructor: DataConstructor; IntegerMinimum, IntegerMaximum: i64?; RealMinimum, RealMaximum: finite f64?; StringMinimumLength: u32; StringMaximumLength: u32?; RecordSupertype: Id?; Default: DataValue?; Unit: string
-   * - Field
-     - Type: TypeRef; Minimum: u32; Maximum: u32?; Unit: string; Direction: ParameterDirection; Storage: FieldStorage; Default: DataValue[]?
-   * - Port
-     - Constructor: PortConstructor; ComponentKind: ComponentPortKind; Orientation: ComponentPortOrientation; LegacyDirection: PortDirection; LegacyInterface: Id?
-   * - Scenario
-     - Viewpoint: ScenarioViewpoint; Context: Id?; Precondition, Postcondition: string
-   * - Lifeline
-     - Represented: Id?
-   * - Occurrence
-     - Constructor: OccurrenceConstructor; Precondition, Postcondition: string; Exchange, Sender, Receiver: Id?; MessageKind: MessageConstructor; TimerExpression: string; ReplyTo, Action, ActionLifeline: Id?; ControlKind: ControlKind; Sequence, Scenario, State, StateLifeline: Id?; FragmentOperator: FragmentOperator; BranchGuard: string
-   * - Event
-     - Constructor: EventConstructor; TimeKind: TimeEventKind; TimeExpression, ChangeExpression: string
-   * - State
-     - Kind: StateKind; Entry, Exit, DoActivity: string
-   * - Constraint
-     - Expression: string
-   * - Relation
-     - Source, Target: Id; AllocationOrder: u32; Transmission: TransmissionProtocol; Acquisition: AcquisitionProtocol; SourceRole, TargetRole: string; SourceMinimum, TargetMinimum: u32; SourceMaximum, TargetMaximum: u32?; SourceNavigable, TargetNavigable: bool; SourcePort, TargetPort: Id; Oriented: bool; ExtendCondition, SequenceGuard: string; TransitionKind: TransitionKind; Trigger, Guard, Effect: string; StateActionPhase: StateActionKind
-
-5.2. Members, rows, order, and attached records
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The remaining facet forms are closed records. ``keys`` means ``{ oa key-or-none;
-sa key-or-none; }``; at least one key MUST be present. ``review`` means the same
-required OA/SA observation pair used above.
-
-.. list-table:: Closed keyed and ordered semantic facets
-   :header-rows: 1
-   :widths: 17 45 38
-
-   * - Outer tag
-     - Required fields
-     - Key / reviewed value type
-   * - Member
-     - collection; keys; review
-     - Id / bool
-   * - Order
-     - collection; review
-     - No keys / Id[]
-   * - Literal
-     - keys; review
-     - Exact case-sensitive string / bool
-   * - Annotation
-     - keys; review
-     - ``{ path Id[]; field Id; }`` / MessageValue?
-   * - Binding
-     - keys; review
-     - Referenced lifeline Id / LifelineBinding?
-   * - Child
-     - keys; review
-     - Direct child Id / bool
-   * - Incident
-     - keys; end; review
-     - Relation Id, end Source or Target / bool
-   * - Artifact
-     - keys; review
-     - Artifact Id / nested artifact facet below
-
-Member.collection is exactly Steps, FragmentBranches, FunctionInputItems,
-FunctionOutputItems, SignalItems, ExchangeItems, TransitionTriggers,
-TransitionEffects or Constrained. Order.collection is exactly Steps or
-FragmentBranches. Order is independent of membership and MUST contain each
-surviving member exactly once when applied. Membership Keep does not refresh
-order history. An automatic insertion requires a unique unchanged mapped anchor;
-ambiguous insertion or conflicting inferred orders requires an explicit final
-target order. Independent removals can filter the order to surviving members.
-
-Annotation identity is the complete ``(path, field)`` pair. Its MessageValue
-payload contains ``path``, ``field`` and ``expression``; the payload key MUST
-match its side's selector key. Binding payloads contain ``referenced`` and
-``local``; ``referenced`` MUST match that side's key. Each row is one atomic
-fact. Changing its key is an explicit old-row removal/new-row addition, not an
-expression-only edit. Defaults containing repeated DataValues are atomic optional
-vectors because those values have no stable member identity.
-
-Artifact.review is ``{ Leaf { oa observation; sa observation; }; }`` where Leaf
-is Presence: bool; Name, Description or Uri: string; Owner: Id;
-Relation: ArtifactRelation; Revision or Fragment: string?. Metadata decisions
-are authorized on the artifact's attachment in the initial project. An explicit
-Owner candidate may move a target-only link and record its resulting Owner and
-other selected metadata. Presence remains relative to the trace owner. Subsequent
-metadata decisions require its new owner trace; historical facts remain attached
-to the trace that recorded them. No review fetches artifact content.
-
-Duplicate scalar selectors and keyed selectors that occupy the same OA slot or
-the same SA slot are invalid, even when the other side's key differs. Historical
-order vectors MUST NOT repeat an Id. Review history has a limit of 16384 facets,
-128 Ids in an annotation path, 1000000 bytes per string, and 1000000 traversal
-steps per baseline. Exceeding these implementation work limits produces a
-diagnostic; truncation MUST NOT be accepted as a complete review.
-
-5.3. Constructor groups and decisions
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Persisted constructors are discriminator words only:
-
-* DataConstructor: Boolean, Integer, Real, String, Enumeration, Record.
-* PortConstructor: FunctionInput, FunctionOutput, Component, Legacy.
-* OccurrenceConstructor: Exchange, Action, Control, SequenceReference,
-  ScenarioUse, State, Fragment, Branch.
-* EventConstructor: Signal, Time, Change.
-* MessageConstructor: Asynchronous, Call, Reply, Create, Delete, Timer.
-
-When a discriminator has no prior fact after explicit resets, both current sides
-are applicable and equal, and the proposed target discriminator is unchanged,
-KeepTarget, TakeSource or Candidate acknowledges only that discriminator.
-It MUST NOT copy a constructor payload, acknowledge unselected descendants or
-retire branch history. Descendant facets may be independently selected in the
-same review; their decisions retain their own scopes and final-value audits.
-Candidate records still MUST NOT change an unselected facet. Missing applicability
-on either side does not qualify as an equal discriminator acknowledgement.
-
-A grouped constructor resolution uses a transient typed target record, then
-records the discriminator and each acknowledged descendant as separate facts.
-It MUST NOT persist a second whole constructor payload overlapping those leaves.
-Data includes its branch fields, literals and coupled default, but excludes Unit.
-Port includes its contract, Legacy fields and item members. Event includes its
-branch fields and Signal items. Occurrence includes its variant payload, members,
-order, annotations and bindings, but excludes outer Precondition/Postcondition.
-MessageKind includes its discriminator and dependent TimerExpression. State.Kind
-is its own structural facet even though it changes the element's derived kind.
-Other dependent changes caused by preparation remain explicit impacts.
-
-A grouped constructor Keep requires an actual discriminator proposal or a
-discriminator change since its prior review. Repeating Keep on an already reviewed
-unequal pair MUST NOT acknowledge unrelated bound/default drift. A real target switch may
-reconsider a previously kept difference. When the target already has the proposed
-constructor, reconciliation MUST preserve target-only members rather than replace
-its whole list. Removed branch facts participate in agreement as NotApplicable;
-facts with neither side remaining applicable are retired.
-
-Semantic review supports these explicit decisions in either direction:
-
-* KeepTarget records the current source and retained target values for only the
-  selected facet, or the explicitly displayed constructor group.
-* TakeSource maps the selected source value through the frozen correspondence and
-  applies only that facet's delta. Unrelated target edits and target-only collection
-  members, rows, children and artifacts remain intact. Removing membership unlinks
-  the target member; it does not authorize deleting the target semantic object.
-* Candidate supplies final existing typed Element, Relation or Artifact records.
-  Only selected facets may differ from the result. Identity, alias and layer are
-  protected. New artifact creation requires a complete candidate and review of
-  every introduced metadata facet; removal also reviews the metadata retirement.
-
-Headers have explicit semantic Name/Description facets; the original prose-only
-workflow remains supported with its own baseline. Ordinary source editing can
-explicitly edit a valid baseline; neither baseline format attests that a human
-performed a particular review workflow.
-Decision requests, final candidates and prepared impacts are transient editor/API
-data. Source persists the resulting ordinary model and typed baseline facts;
-it does not persist KeepTarget/TakeSource/Candidate as extra facet fields.
-
-5.4. Correspondence, agreement, and atomic preparation
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Correspondence is an explicit canonical OA-to-SA Id map, including historical
-deleted IDs. Names and aliases MUST NOT guess correspondence. Reverse application
-uses its inverse and rejects ambiguity. Multiple trace kinds for one endpoint
-pair require an explicit trace selection. Changing a keyed pairing requires an
-explicit reset naming the prior selector; old pairs are never silently replaced.
-If a previously paired member or branch disappears on one side, retain its pair
-with the absent/NotApplicable observation, suppressing a redundant one-sided
-projection. A newly appearing pair still requires reset of old one-sided history.
-
-All selected source proposals use one immutable initial project. Resets precede
-catalog and constructor-scope derivation. Many sources may affect one target only
-when their desired values agree on every actual canonical target slot, including
-removals and members introduced by another proposal. Child membership and the
-actual child's Parent share one slot; incidents share the relation's Source or
-Target endpoint; artifact Presence and Owner share the actual artifact owner slot.
-Conflicting desired values MUST reject independently of request order.
-
-Materialize the agreed writes once, then audit each desired selected value.
-Prepare one ordinary complete Command batch and compare its actual project with
-the explicitly reviewed candidate. Additional cleanup, such as inherited message
-annotation pruning, is reported as exact object ``before``/``after`` typed records
-(or absence for creation/deletion). Every induced impact requires explicit review;
-an accepted impact still MUST NOT contradict a selected Keep/Take. Repeat the
-selected-value audit after preparation. Baseline updates belong to the same atomic
-transaction and source-preserving writeback as model edits.
-
-A plan's base fingerprint detects a stale model; its prepared fingerprint checks
-candidate consistency. The plan is client-supplied data, not an authenticated
-receipt or proof of its original decisions. Applying it validates the complete
-ordinary candidate and preserves generated identities; it does not re-run its
-request to generate new identities. Hosted clients additionally use the revision
-preconditions defined in ``api.rst``. Invalid/stale plans or failed source writeback
-leave the accepted model, source, baseline, revision and history unchanged.
-
-Own drift and linked impacts are separate, with incomplete review explicitly
-visible. Absent facts MUST NOT produce a falsely complete Unchanged rollup.
-Shared data/interface/event definitions are reviewed on their own traces; their
-bounded derived impact walk follows reusable definitions and interface allocations,
-not arbitrary architectural neighborhoods, and does not copy them into every
-referrer's baseline. Its limits are 4096 objects per side and 32768 edges; exhaustion
-is a diagnostic. Successful review remains one undoable transaction. Replanning
-unchanged, already acknowledged leaf facts is a no-op only while their requests
-remain applicable. A completed constructor switch or first acknowledgement of an
-equal discriminator MUST be removed from subsequent requests; repeating it when
-no switch remains is rejected. After an artifact moves to another owner,
-metadata review through the old owner's trace is no longer
-applicable and is rejected. An old plan becomes stale after an actual committed
-change.
-
-5.5. Source examples and historical token rules
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-This valid source records deliberately different constructor/unit observations.
-Its historical integer minimum is absent; the Real side has no integer branch::
-
-    arcadia 5;
-    project reviewed_dimensions "Reviewed dimensions" {
-        oa_data_type oa_dimension "Operational distance" {
-            definition { Integer { minimum 0; maximum 10; }; };
-            unit "m";
-        }
-        sa_data_type sa_dimension "System distance" {
-            definition { Real { minimum 0; maximum 20; }; };
-            unit "ft";
-        }
-        trace dimension_review "Dimension review" {
-            oa @oa_dimension;
-            sa @sa_dimension;
-            kind Item;
-            baseline {
-                oa { name "Approved OA name"; description ""; };
-                sa { name "Approved SA name"; description ""; };
-                semantic { facets [
-                    { Data { Constructor { oa { Value Integer; }; sa { Value Real; }; }; }; },
-                    { Data { IntegerMinimum { oa { Value none; }; sa NotApplicable; }; }; },
-                    { Data { Unit { oa { Value "m"; }; sa { Value "ft"; }; }; }; }
-                ]; };
-            };
-        }
-    }
-
-Historical Id slots require ``uuid "..."`` even if the object still exists.
-Only typed reference slots inside ``baseline.semantic`` accept that atom.
-For example, the following is a valid historical facet value, including a deleted
-named type; ``none`` and bare enum Boolean retain their different typed meanings::
-
-    { Field { Type {
-        oa { Value { Named uuid "40000000-0000-4000-8000-000000000090"; }; };
-        sa { Value Boolean; };
-    }; }; }
-
-A qualified annotation uses the same historical UUID atoms in its key and payload.
-This complete facet records one old row and an applicable absent target row::
-
-    { Annotation {
-        keys {
-            oa {
-                path [uuid "40000000-0000-4000-8000-000000000091"];
-                field uuid "40000000-0000-4000-8000-000000000092";
-            };
-            sa none;
-        };
-        review {
-            oa { Value {
-                path [uuid "40000000-0000-4000-8000-000000000091"];
-                field uuid "40000000-0000-4000-8000-000000000092";
-                expression "latitude + 1";
-            }; };
-            sa { Value none; };
-        };
-    }; }
-
-Historical enums require bare words. Ordinary strings, including UUID-looking
-units, literal keys and expressions, require quoted strings and remain text
-during identity remapping. ``@alias`` is invalid anywhere inside a semantic
-baseline. Live parents, trace endpoints and all other live references still
-require ``@alias`` and MUST NOT accept the historical UUID atom.
-
-The following substitutions in these examples are invalid:
-
-* ``oa "NotApplicable";`` or ``oa { Value "Integer"; };`` in the Constructor
-  review: enum observations require bare words of the correct typed enum.
-* ``Named "40000000-0000-4000-8000-000000000090";`` or ``Named @oa_dimension;``:
-  a historical Id requires the explicit UUID atom.
-* ``Unit { oa { Value uuid "40000000-0000-4000-8000-000000000090"; }; ... }``:
-  a text field cannot hold a reference atom.
-* Repeating the Unit facet, adding an unknown leaf, or supplying a numeric bound
-  as a quoted string: closed typed admission rejects the whole candidate.
-* Changing only the annotation payload's field UUID suffix from 092 to 093,
-  leaving the key at 092: the row's key and payload disagree.
-* Changing the document header to ``arcadia 4;`` while retaining ``semantic``:
-  the frozen earlier schema does not admit a future baseline shape.
-
 6. Text grammar and resolution
 ------------------------------
 
@@ -1364,7 +875,7 @@ sets and enum constructors are closed by sections 3–5.
 
 .. code-block:: text
 
-    document    = "arcadia" "5" ";" project
+    document    = "arcadia" "3" ";" project
     project     = "project" alias string identity? "{" project-entry* "}"
     project-entry = "description" string ";" | declaration
     declaration = element
@@ -1376,8 +887,7 @@ sets and enum constructors are closed by sections 3–5.
     identity    = "id" uuid-string
     fields      = "{" (field-name value ";")* "}"
     value       = string | number | "true" | "false" | "none"
-                | enum-word | "@" alias | historical-id | list | fields
-    historical-id = "uuid" uuid-string
+                | enum-word | "@" alias | list | fields
     list        = "[" (value ("," value)*)? "]"
 
 The project description defaults to empty and may appear once. There is no
@@ -1399,9 +909,6 @@ produces UUID references; the alias itself remains stored on its declaration.
 Changing an alias in source requires updating its uses. Display names never
 resolve references.
 
-``historical-id`` is context-restricted to the typed semantic baseline reference
-slots in section 5.5; it is not an alternative spelling of a live reference.
-
 Unknown fields, duplicate fields, incompatible constructor payloads, unsupported
 enum spellings, duplicate aliases/identities, and structural validation errors
 reject the entire candidate. No declaration silently replaces another.
@@ -1410,18 +917,18 @@ Ordinary string fields require quoted strings and cannot contain an unquoted
 constructor records. Typed values MUST NOT nest more than 64 levels; malformed
 deeply nested drafts produce a diagnostic instead of exhausting the parser stack.
 
-6.1. Modular source projects
+6.1. Modular source3 projects
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The pure ``source_project`` core API compiles a virtual source bundle, containing
 ``entry`` and a ``files`` map from logical paths to UTF-8 strings. Its entry is a
-root-level ``.arcadia`` file with the source5 project header above. A project entry
+root-level ``.arcadia`` file with the source3 project header above. A project entry
 MAY also be ``include string ";"``. An included fragment consists only of ordinary
 declarations and include statements; it MUST NOT contain another version header,
 project wrapper, or project description. Includes MUST occur at document level,
 never inside an element body or typed field value. For example::
 
-    arcadia 5;
+    arcadia 3;
     project rescue "Rescue" id "00000000-0000-4000-8000-000000000001" {
         description "Operational model";
         include "oa/participants.arcadia";
@@ -1487,17 +994,9 @@ spans never refer to concatenated or synthetic source.
 
 Single-string parse/lint APIs remain filesystem-free and reject include
 statements with an explicit source-bundle requirement. V1/V2 single-file imports
-continue through explicit migration. Modular projects accept source3, source4 and
-source5. Source3 is upgraded as one project, preserving file paths, includes, nested
-ownership and comments through targeted token edits. Generated allocation
-declarations stay in their interface's existing file. Individual include fragments
-are not independently migrated. Missing UUIDs stabilize before migration so new
-allocation identities are deterministic on subsequent compilation.
-An authored source4 bundle upgrades through the strict prose-only baseline
-adapter; after any missing UUID stabilization, the version token alone changes
-to 5. Existing prose, comments, includes and nested ownership remain intact.
-Source5 semantic facet comments follow their closed selector identity through
-row reordering and reidentification; UUID-looking text does not act as an Id.
+continue through their existing migration readers and reports. Modular projects
+require source3; migration is performed before modular export, not independently
+on included fragments. Modular source does not change the semantic JSON schema.
 
 6.2. Nested element ownership
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1729,44 +1228,10 @@ explicitly before Apply succeeds.
 
 Loading detects JSON from its first non-whitespace ``{``; other input is parsed
 as Arcadia source regardless of filename. Saving an ``.arcadia`` suffix uses
-the accepted V5 source bundle (``arcadia 5``); other suffixes use V5 JSON. Both forms preserve the same
+the accepted V3 source bundle (``arcadia 3``); other suffixes use V3 JSON. Both forms preserve the same
 complete model. JSON rejects unknown fields throughout typed payloads,
 duplicate maps, unsupported versions, and structural errors.
 
-The explicit schema-4 reader retains the exact old Project/Trace/TraceBaseline
-envelope with closed fields. It reuses unchanged typed elements, relations,
-diagrams and artifacts. Version4 prose baselines migrate with semantic none;
-their names/descriptions remain exact even when live endpoint values differ.
-The adapter MUST NOT infer semantic review from live values, and version3/4
-inputs MUST reject semantic baseline fields. The migration report retains the
-original from_schema and current to_schema 5. Reopening a current5 save produces
-no migration report. The real V4 reviewed-prose fixtures remain compatibility input.
-
-The schema-3 reader freezes the changed data payloads and old constructor catalog;
-schema-4 fields/constructors MUST NOT be silently accepted as schema 3. Existing
-typed PortContract records remain unchanged. Information/Material/Energy retain
-their nature with Unspecified mechanism; old Event becomes Information with Event
-mechanism. Old bounds/defaults/supertypes are absent, String length is 0..unbounded,
-and fields retain type/multiplicity/unit with Unspecified direction, Value storage
-and no explicit default. No physical mechanism or direction is guessed.
-
-Each old Interface.items entry generates one InterfaceItemAllocation with its
-original zero-based order and Unspecified protocols. UUID v5 uses the project UUID
-namespace and name ``v2-interface-item:<interface-uuid>:<item-uuid>`` consistently
-for schema-2 and schema-3 inputs. Aliases are deterministic and collision-free;
-collision with any existing identity is an error rather than an overwrite. Existing
-interface/item identities remain intact. Old nested message values acquire a path
-only when exactly one valid path exists. Ambiguous paths, including recursive
-reuse, retain the old annotation with a located warning rather than guessing.
-
-Migration reports additionally contain ``semantic_defaults`` (object, field,
-description), ``generated_interface_allocations`` (id, source, target, alias,
-order) and ``unresolved_message_values`` (occurrence, field, reason). These new
-report arrays default empty when reading older responses. Version 1 normalizes
-through V2, then the typed-port V3 adapter, shared V4 data upgrade and V5 review
-adapter. Original V2 and real V3 fixtures remain unchanged compatibility inputs. Current exports
-always use version 5; reading/migrating alone never saves or changes revisions.
-
 Native source Save All checks the original contents of observed dependencies
 before staging writes. Existing target files are replaced individually and the
 entry is installed last. A transaction journal records originals and intended
@@ -1791,7 +1256,7 @@ defaults without changing any prior identity, name, reference, order, geometry,
 artifact or trace field. The original V2 golden source/JSON in
 ``crates/oa-core/tests/fixtures`` MUST NOT be regenerated from the newer demo;
 they verify that every old persistent field survives. Canonical output writes
-the added defaults through the explicit schema-3, schema-4 and schema-5 migrations.
+the added defaults through the explicit schema-3 migration.
 
 The V2 adapter preserves every original identity, alias, prose, parent,
 placement, trace and artifact. Generic ports become Legacy with their original
@@ -1810,14 +1275,14 @@ IDs, required resolutions, generated endpoint IDs/aliases/owners, and boundary
 orientation defaults. REST import, replacement, candidate validation and
 project snapshots surface the same report. Opening an old server envelope
 preserves its resource ID/revision and bytes; the next explicit edit writes
-schema 5. Model/source exports contain only the canonical model. Migration
+schema 3. Model/source exports contain only the canonical model. Migration
 reports are transient response metadata, not persisted model facts.
 
 Admission checks account for generated objects and their references before
-construction. Both the old V2 contract and the resulting V5 graph are
+construction. Both the old V2 contract and the resulting V3 graph are
 validated. Migration itself does not save or increase a stored revision.
 Canonical second saves are stable. V1 normalization produces the frozen V2
-model and then uses these same V2-to-3-to-4-to-5 stages.
+model and then uses this same V2-to-3 stage.
 
 Save validates a snapshot, writes a sibling temporary file, flushes it, and
 atomically replaces the destination. Failed serialization or validation must
@@ -1836,7 +1301,7 @@ step becomes a distinct occurrence element owned by its process. Generated
 diagram, node, and occurrence identities use UUID v5 with the old Project ID
 as namespace and deterministic role/index names. If such an identity collides,
 a deterministic suffix is tried. Reimporting the same fully identified V1
-input therefore yields the same V5 result, including repeated occurrences.
+input therefore yields the same V3 result, including repeated occurrences.
 No System or SA content is invented during an OA-only migration.
 
 V1 source aliases are retained when valid in V2. JSON imports generate the old
@@ -1844,7 +1309,7 @@ canonical aliases deterministically. Any alias newly reserved in V2 is changed
 by a deterministic suffix; aliases were not persistent V1 semantic data.
 A project alias and aliases for new records are generated without colliding
 with retained aliases. The existing bundled V1 text and JSON migrate to equal
-V5 projects. Future versions remain errors until a separate migration exists.
+V3 projects. Future versions remain errors until a separate migration exists.
 
 10. Complete authoring example
 ------------------------------
@@ -1854,7 +1319,7 @@ the assigned UUIDs explicitly.
 
 .. code-block:: text
 
-    arcadia 5;
+    arcadia 3;
     project harbor "Harbor assistance" {
         oa_entity control "Harbor control" {}
         oa_activity assess "Assess assistance" {}
@@ -1893,14 +1358,6 @@ deterministic V1 migration, occurrence identity, coordinate bits, persistence,
 and model-history integration. Core validation and session tests cover domain
 mutation rules; native UI and API verification are separate evidence.
 
-``cargo test -p oa-core --test r3_semantic --test r3_source --test r3_migration --locked``
-checks the closed facet catalog, partial decisions, constructor scopes, canonical
-agreement, target-only preservation, historic references, exact prepared impacts,
-source/JSON parity, comment ownership and explicit original1–4 migration. The
-source suite includes actual included-file save/reopen and prepared review
-writeback. These checks establish core/source behavior; they do not establish
-graphical or hosted API acceptance by themselves.
-
 The research record in ``docs/research-v2-semantics.md`` distinguishes method
 requirements from Studio design choices and links to original UI evidence.
 The following sources inform this language without extending its scope:

docs/scope.md

@@ -8,12 +8,12 @@ Arcadia Studio implements a systems-engineering workbench spanning Operational A
 |---|---|
 | Operational Analysis | Entities, actors, roles, activities, missions, capabilities and processes; entity/work decomposition; leaf allocation; role realization/assignment; interactions and capability/process involvement |
 | System Analysis | One System of Interest, external Actors, functions, missions, capabilities and functional chains; functional decomposition independent of the system boundary; allocation, functional/boundary exchanges and mission-capability links |
-| Data and interfaces | Information/material/energy nature and Flow/Event/Operation/SharedData mechanisms, bounded primitive/enum/record types, typed defaults, field multiplicity/units/direction/storage, specialization, identified interface allocations and reference associations, separate function input/output and Standard/Flow component ports, interface provision/requirement, port and exchange allocations |
+| Data and interfaces | Information/material/energy/event exchange items, primitive/enum/record data types, typed fields with multiplicity/units, separate function input/output and Standard/Flow component ports, interface provision/requirement, port and exchange allocations |
 | Behavior | Process/chain work and exchange contributions, control topology and sequence reuse; scenario lifelines, correlated calls/replies, timers, action/state occurrences, ALT/PAR/LOOP/OPTIONAL fragments, scenario reuse and pre/postconditions |
 | States and conditions | Participant-owned state machines, nested regions, states/modes and typed pseudostates, signal/time/change events, trigger/guard/effect transitions, linked entry/do/exit work, availability and constraints |
 | Perspectives and evidence | Bidirectional counterpart creation/linking, reviewed name/description updates, many-to-many typed/manual traces, arbitrary artifact URI/revision/fragment references |
 | Views and editing | Independent diagrams, decomposition/allocation nesting, collapse, pan/zoom/Fit/Arrange, editable connection routes and labels, four-side port positioning, direct interaction/functional/boundary exchange tools, contextual menus, SVG export, model explorer and typed properties |
-| Text and storage | `arcadia 4` source projects with relative includes and nested declarations, stable aliases/UUIDs, a source-file tree, per-file drafts and diagnostics, comment-preserving graphical updates, exact model/source Undo/Redo, legacy migration, atomic saves and interrupted source-save recovery |
+| Text and storage | `arcadia 3` source projects with relative includes and nested declarations, stable aliases/UUIDs, a source-file tree, per-file drafts and diagnostics, comment-preserving graphical updates, exact model/source Undo/Redo, legacy migration, atomic saves and interrupted source-save recovery |
 | Automation | Rust REST service for project/source-bundle/query/validation/transaction/transition/artifact workflows, ETag preconditions, bounded requests and atomic current-revision storage |
 
 Graphical and textual parity applies to the persistent fields of this profile. Diagram placements are model data; camera, selection, source cursor and undo history are session state. Canvas gestures need not match textual operations one for one: typed inspectors and explicit commands expose precise semantics. Full source replacement must repair dependencies in its candidate, while graphical delete/reidentify commands maintain references automatically.
@@ -45,7 +45,7 @@ These are concrete design responses, not claims that every Capella user experien
 
 ## Required first-release work
 
-Direct scenario/process canvas authoring, semantic-content drift and reviewed counterpart reconciliation, native acceptance of expanded data contracts, persistent coverage/filter views, Home/recent-project and unsaved-work recovery, hosted desktop editing, guidance and final acceptance remain in the [release plan](../harness/PLAN.md). These are unfinished requirements, not exclusions from the release. Direct state editing has scoped Windows/Linux acceptance recorded in [state evidence](../harness/release-state-editing.md). Interrupted source-save recovery restores a save transaction; it does not checkpoint unsaved models or drafts.
+Direct state/scenario/process canvas authoring, semantic-content drift and reviewed counterpart reconciliation, expanded data contracts, persistent coverage/filter views, Home/recent-project and unsaved-work recovery, hosted desktop editing, guidance and final acceptance remain in the [release plan](../harness/PLAN.md). These are unfinished requirements, not exclusions from the release. Interrupted source-save recovery restores a save transaction; it does not checkpoint unsaved models or drafts.
 
 ## Remaining boundaries
 

docs/server.md

@@ -1,6 +1,6 @@
 # Arcadia Studio server
 
-`arcadia-server` is a headless Rust REST service for the same schema-4 model, commands, source language, validation, artifacts and OA/SA traces used by the desktop. It stores each model and its authored source project together in an atomic JSON envelope. The service provides a deployment artifact and configuration examples; this repository does not assert that a remote instance has been deployed.
+`arcadia-server` is a headless Rust REST service for the same schema-3 model, commands, source language, validation, artifacts and OA/SA traces used by the desktop. It stores each model and its authored source project together in an atomic JSON envelope. The service provides a deployment artifact and configuration examples; this repository does not assert that a remote instance has been deployed.
 
 The complete HTTP contract is [api.rst](api.rst); machine-readable schemas are in [openapi.json](openapi.json), also served at `/api/v1/openapi.json`. The original [service research](research-v2-service.md) discusses broader alternatives; retained history, SQLite, idempotency receipts and stored transition plans from that research are **not** the implemented storage contract.
 
@@ -44,7 +44,7 @@ The data directory contains `.arcadia.lock` and one `<resource-id>.json` file pe
 
 Startup validates every committed envelope, its filename/UUID, revision, size and complete model. Any corrupt or unsupported envelope stops startup; the service does not silently skip bad data or invent an empty replacement. Sibling `.arcadia-write-*` files from an interrupted pre-commit write are not committed models and are ignored on startup.
 
-Earlier model-only envelopes are accepted through the existing model migrations and receive deterministic source files in memory. Opening, reading or an exact no-op neither rewrites those envelopes nor advances their revision. The next changed edit persists the coupled representation. Already-coupled schema3 envelopes explicitly migrate both representations in memory; the independently migrated graphs must agree. Current-format source must contain stable IDs. Inconsistent pairs are rejected at startup. Migration reports remain visible until a current-format edit/save; opening alone never rewrites the envelope. Capacity accounting includes source generated in memory for old envelopes, so an over-capacity old store fails explicitly without rewriting or pruning it.
+Earlier model-only envelopes are accepted through the existing model migrations and receive deterministic source files in memory. Opening, reading or an exact no-op neither rewrites those envelopes nor advances their revision. The next changed edit persists the coupled representation. Already-coupled envelopes must contain stable source IDs and matching model/source; inconsistent pairs are rejected at startup. Capacity accounting includes source generated in memory for old envelopes, so an over-capacity old store fails explicitly without rewriting or pruning it.
 
 Parsing, validation and blocking disk operations run on blocking workers. A shared store mutex captures snapshots and serializes final revision checks and writes. Parsing, semantic validation, source writeback and query processing use the captured snapshot outside that lock; an expensive candidate does not block the catalog or another model's preparation. Commit rechecks the exact ETag, so a candidate prepared against a superseded snapshot returns `412 revision_conflict`. A successful changed update increments revision once. Both model and source bundle must be unchanged for `changed: false`; comment-only edits advance the same revision. Each write serializes the whole envelope to a sibling temporary file, syncs it, and atomically replaces the destination. Unix also syncs the directory. The in-memory snapshot changes only after the replacement succeeds. A directory-sync error after replacement is reported as an uncertain write outcome while the in-memory head still matches the installed file.
 

harness/DECISIONS.md

@@ -14,21 +14,6 @@
 - **Evidence governs completion.** Original Capella was operated in an isolated example and its useful nesting/navigation/transition patterns informed the UI. Independent reviews, real native workflows and automated invariants complement each other. Platform and feature boundaries remain explicit in validation/scope documents.
 # First-release decisions (supersede narrower V2 exclusions below)
 
-- R3 production adopts closed typed per-facet reviews (C), selected after the
-  11-case proof in b2ab2b1 and independent adversarial review. Each self-tagged
-  fact stores independently reviewed OA/SA typed values; absent facts remain
-  Unreviewed, and NotApplicable distinguishes an absent constructor branch from
-  an absent optional value. This supersedes recursive SemanticValue/string paths
-  and typed-body carrier/mask/order-shadow baselines. Extra finite adapter code
-  is accepted for fewer persisted-state invariants, not as a generic metamodel.
-  Atomic keyed rows, target-only preserving member deltas, independent order,
-  exact constructor groups, explicit mapping resets/canonical target agreement
-  and actual prepared-impact review remain required. Keep the existing Command
-  and transition planner boundaries. Artifact reviews attach to semantic traces.
-  Schema/source5 is explicit, with unchanged data4 compatibility. The authoritative
-  implementation/ownership/evidence contract is release-semantic-review-implementation.md;
-  production implementation and release acceptance are still pending.
-
 - OA/SA semantic scope follows `release-semantics-audit.md` R1–R6 and actual Capella workflow evidence. Later Arcadia layers remain future work; missing OA/SA reuse, topology, state/data contracts and semantic transition review do not become release limitations.
 - Preserve one typed Rust core and atomic validated model commands. Mission/capability links and process topology are independent of containment and diagram placement. Work/chain reuse uses stable reference occurrences rather than copied semantic objects; sequence guards belong to contextual links rather than global exchanges.
 - Desktop lint uses one background parser plus the latest queued source version. Accepted model checks are cached separately from draft diagnostics. Stale results cannot enter a different document or overwrite newer edits. The REST service prepares bounded candidates outside its global store lock and rechecks ETags during commit.
@@ -78,36 +63,3 @@ State camera/tool lifetime follows effective machine and diagram identity, even
 when selection changes through Catalog or Layer outside Behavior. Reset only on
 actual context change; preserve same-view return. Independent review reproduced
 the leak and native Windows/Linux tests verified the correction in316dc55.
-
-## Semantic review proposals and historical admission (2026-09-06)
-
-R3 stores closed, typed, independently reviewed OA/SA facet pairs. Constructor
-facts store discriminators only; explicit group decisions enumerate and retire
-their exact branch facts. No persisted recursive value tree, own-record carrier,
-review mask or order shadow is introduced. The complete contract is
-release-semantic-review-implementation.md.
-
-Derive every source proposal from the same immutable initial project. Reset old
-mapping selectors before deriving scopes; compare all desired canonical target
-slots, including constructor removals, before one materialization. Audit selected
-values against both that result and the ordinarily prepared project. This prevents
-sequential last-write wins, even when one source introduces a member another
-constructor removes. Preserve target-only members during same-target-constructor
-reconciliation. Artifact attachment and explicit owner changes share the actual
-artifact's owner slot; child/incident operations similarly share actual parent or
-endpoint slots. Exact prepared cleanup impacts require explicit acknowledgement
-and may not contradict a selected Keep/Take.
-
-Artifact metadata is observed by identified record after authorization against
-its initial attachment. An owner move therefore retains the actual resulting
-Owner/Name facts, including target-only links; Presence remains owner-relative.
-New metadata decisions require the current attached owner trace. Historical paired
-selectors survive disappearance of one side and suppress redundant one-sided
-projections. A new pairing cannot suppress prior one-sided history without reset.
-
-Current resolution applicability and historical baseline admission are separate.
-New decisions require a compatible current family and an applicable side; historical
-typed facts can outlive former constructors/families and deleted references. Their
-typed reference visitor supports explicit reidentification but does not add live
-deletion dependencies. Derived linked-definition drift remains bounded and exposes
-missing review coverage instead of copying a shared definition into every baseline.

harness/PLAN.md

@@ -4,7 +4,7 @@
 
 Deliver the first release of Arcadia Studio for system engineers: complete Operational Analysis and System Analysis/System Architecture workflows, equivalent graphical and textual models, clear artifact traceability and a deployable/programmatically accessible Rust service. Logical/Physical Architecture and later Arcadia layers are future releases, as the new objective explicitly states.
 
-The authoritative objective is attachment10134df9-bea2-4c02-a820-67b53d6b86f7/goal-objective.md. It retains first-release scope and source/include, drag-selection and direct behavior editing requirements, and strengthens domain coherence, alternative evaluation and target-user task evidence. TASK_LEDGER.md separates given/verified facts, assumptions and open candidates; STATE.md records progress. The accepted0.2.0 prototype is the baseline, not proof of release completeness. Its source is preserved at D:/CodexBuilds/Capella2-release1-01a06e2e/v2-source-baseline.zip and existing archives remain in dist until replacement passes acceptance.
+The authoritative objective is attachment07aee762-7d27-4cbe-81c3-2e82c7170711/goal-objective.md. It retains first-release scope and source/include, drag-selection and direct behavior editing requirements, and strengthens domain coherence, alternative evaluation and target-user task evidence. TASK_LEDGER.md separates given/verified facts, assumptions and open candidates; STATE.md records progress. The accepted0.2.0 prototype is the baseline, not proof of release completeness. Its source is preserved at D:/CodexBuilds/Capella2-release1-01a06e2e/v2-source-baseline.zip and existing archives remain in dist until replacement passes acceptance.
 
 ## Existing architecture and retained decisions
 

harness/STATE.md

@@ -7,11 +7,11 @@ Operational Analysis and System Analysis/System Architecture, equivalent graphic
 textual and REST semantics, artifact traceability, directly editable behavior,
 offline guidance, and Windows/Linux release evidence. Later Arcadia layers remain
 future releases. The full authoritative objective was reread on 2026-09-06:
-attachment10134df9-bea2-4c02-a820-67b53d6b86f7/goal-objective.md.
+attachment07aee762-7d27-4cbe-81c3-2e82c7170711/goal-objective.md.
 PLAN.md retains the entire release scope; no subsystem acceptance completes it.
 
 Direct state-machine editing is accepted through production316dc55. The main
-checkout was fast-forwarded to acceptance a8f451e. R6 data/interface contracts are now
+checkout can fast-forward to this integration. R6 data/interface contracts are now
 being implemented in a separate checkout; they are not accepted or released.
 Meaningful implementation and runtime progress continues; no external blocker exists.
 
@@ -76,54 +76,18 @@ Dedicated target D:/CodexBuilds/Capella2-data-target. Contract freeze is schema/
 with full data payload and dictionary slices together; existing typed ports remain.
 See release-data-implementation.md and release-data-contract.md in that checkout.
 
-Core is committed0b58107; source/migration1230ab8. Root API/docs are integrated
-on the same working tree; desktop remains in flight and R6 is not accepted.
-Core15 R6 +28workflow tests passed again after final allocation-arrow suppression.
-Linux0b58107 full core307 tests passed (one explicit probe ignored by default),
-with strict all-target core Clippy. Earlier13ports/14scenarios and115 source/lib
-tests also passed. Desktop final257 tests and strict all-target Clippy pass;
-optimized Windows desktop build b403039 passed. Its SHA256 is recorded in the R6 verification note; native acceptance remains pending.
+Ownership: data_core owns core model/data/validation/references/ports/transitions
+and non-source tests; state_architecture_review owns source/migration/persistence
+and their tests; drawing_correctness owns desktop. Root owns API/OpenAPI/reST,
+integration and native input. Do not edit workers' files or reset their changes.
 
-Root41 server tests passed; a fourth R6 HTTP workflow now also passes, alongside all4 data HTTP tests and strict server Clippy. The original3 actual HTTP workflows for the published
-data example, protocol/artifact identity, atomic rejected defaults, query/export,
-reidentify/delete/restart, source3 bundle migration reports and old coupled3
-envelope upgrade without write/revision. Tests exposed dropped bundle reports and
-rejected legitimate old source/model pairs; both root fixes passed retest.
-Strict reST HTML generation and81 OpenAPI schema definitions passed. Actual frozen
-server32033FFE imported the published example; its complete Project/StoredProject
-responses passed served/current JSON Schema validation and obsolete shapes rejected.
-Evidence: api-r6-contract and r6-server-tests-after.log under the release directory.
-
-Independent core review found association transition closure pulling unrelated
-types and missing empty-enum warning; both corrected and focused tests passed.
-Repeated per-ancestor full scans were simplified to one scan per helper call.
-Explicit optimized inheritance timings250/500/1000: Windows21.070/89.088/391.590ms,
-Linux22.381/111.662/408.129ms. These single-run empty-chain fixtures measure core
-validation, not general UI latency. A1000-deep chain remains a pathological cost.
-
-Independent desktop review fixes now pass tests: a focused dictionary with24-row
-pages replaces unbounded inherited rows; recursive paths support explicit drill-down
-and imported finite paths; same-phase styles/same-exchange reselection preserve
-valid drafts. Read-only follow-up found no new path/style defect. Paging resets
-only on actual layer/document changes; its regression failed before and passes now.
-Root found another unresolved scale issue: scenario creation still enumerates every
-carried field into both a dropdown and individual input rows. A bounded focused value editor is now implemented and under automated/independent review; actual native operation remains required before R6 acceptance.
-
-Current ownership: drawing_correctness owns desktop except root-owned guide.rs and
-the dedicated Windows Cargo target. state_architecture_review independently reviews
-R6 spec/API consistency; its data_view.rs ownership has ended. data_core runs an
-isolated R3 typed-baseline experiment; Linux R6 core checkout is idle and verified.
-Root owns API/OpenAPI/reST, docs, integration and native input. No concurrent writers.
-
-1. State evidence is committed and main fast-forwarded to a8f451e; DATA received
-   the same evidence in c5276b1. Finish native data-authoring acceptance and bounded
-   scenario-value authoring, then full integrated Windows/Linux verification.
+1. Commit state evidence and fast-forward main from ad7feb5; coordinate Git index
+   before carrying documentation into the active R6 checkout.
 2. Finish R6 core/source/desktop, integrate actual REST/schema/reST, independent
    semantic/correctness/UX review, Windows/Linux checks and real data authoring.
-3. Integrate the verified R3 core/source checkpoint from the isolated semantic-review
-   checkout, then complete desktop/server and native/platform acceptance. The closed
-   typed per-facet representation (C) and its immutable-proposal rule are recorded
-   in release-semantic-review-implementation.md; this is not release acceptance.
+3. Implement R3 typed semantic drift/reconciliation after R6 freezes. Current
+   baselines/reconciliation only cover prose. Prefer historical typed-body snapshots
+   and finite proposals; avoid a duplicate recursive semantic schema without evidence.
 4. Complete direct scenario/process gestures, persistent coverage/filters,
    Home/recent/recovery, hosted desktop ETag workflows and offline guidance.
 5. Fresh final requirements/domain/correctness/native UX/architecture review; full
@@ -131,85 +95,6 @@ Root owns API/OpenAPI/reST, docs, integration and native input. No concurrent wr
 
 ## Environment and native ownership
 
-R3 is authorized in D:/CodexBuilds/Capella2-semantic-review, branch
-codex/semantic-review, baseab661f2, dedicated target Capella2-semantic-target.
-Core owns typed facets/catalog/drift/mapped review and atomic preparation; source
-worker owns schema/source5 compatibility and language integration. Both preserve
-data4 and the existing Command boundary. The 11-case C proof and independent
-critic justified direct typed facts instead of carrier masks/order shadows; more
-adapter code is accepted for fewer persisted invariants. This is an active
-implementation checkpoint, not R3 acceptance. Root owns concurrent R6 native work.
-
-## R3 core/source frozen checkpoint (2026-09-06)
-
-The isolated semantic-review tree now contains the complete 84-scalar/13-family
-catalog, keyed member/order/annotation/binding/child/incident/artifact facts,
-bounded linked-definition drift, typed historical reference/remap/admission, and
-bidirectional mapped review through one ordinary prepared Command batch. Source
-and strict schema1–4→5 compatibility are committed in ab960cb; this core checkpoint
-adds the closed review implementation. Desktop/API integration and Windows/Linux
-native/platform acceptance remain root-owned work. No native input was used here.
-
-Every source derives proposals from one immutable initial project. Reset old
-selectors before scope derivation, compare the union of selected canonical target
-slots (including constructor removals), materialize once, then audit every desired
-value before and after command preparation. Same-target constructor reconciliation
-preserves target-only members; induced cleanup needs exact explicit review and
-cannot override an independently selected Keep/Take. Historical facts may outlive
-former record families/deleted UUIDs; new resolutions still require current family
-and leaf applicability. DECISIONS records why these are distinct admission rules.
-
-Independent review's original five findings and four residuals are covered by these
-passing cases in crates/oa-core/tests/r3_semantic.rs:
-
-| Finding | Closure regression |
-| --- | --- |
-| Repeated unequal constructor Keep hides bound drift | repeated_keep_of_unequal_constructor_pair_cannot_swallow_bound_drift |
-| StateKind change fails legacy mapping preflight | changed_state_kind_remains_reviewable_in_both_directions |
-| Artifact metadata writes collide through different owner traces | artifact_metadata_is_attached_and_cannot_last_write_through_two_owner_traces |
-| Constructor retirement overrides another source's Keep | constructor_retirement_cannot_override_other_sources_kept_bound_in_either_order |
-| Partial review falsely rolls up as unchanged | semantic_rollup_does_not_claim_unchanged_when_only_unit_is_reviewed |
-| Another source's introduced member escapes constructor removal agreement | constructor_union_conflicts_with_another_sources_new_member_in_either_order |
-| Source constructor history causes target-only member loss | same_target_constructor_preserves_local_members_and_reset_precedes_expansion |
-| Reset old mapping selector reappears during group expansion | same_target_constructor_preserves_local_members_and_reset_precedes_expansion |
-| Artifact Owner cannot explicitly move the attached link | artifact_owner_candidate_moves_link_and_conflicts_with_kept_attachment |
-
-The additional combined_ordered_membership_commutes_or_requires_agreed_anchors
-case verifies both request orders: independent removals preserve the local member;
-contradictory inferred insertion anchors reject. Coverage includes atomic rollback,
-one undo/redo, stale plans, no-op replanning, explicit cleanup acknowledgement,
-partial Keep/Take, qualified rows, mapping resets and historical deleted refs.
-
-Final bounded follow-up extends those same Owner/reset findings:
-target_only_artifact_move_records_owner_and_metadata_in_either_order covers an
-unpaired target link, Owner alone and Owner+Name in either order, actual resulting
-typed owner history, and rejected future metadata review through the former owner.
-retired_source_branch_retains_historical_member_pair_in_both_directions preserves
-the established pair after a branch disappears instead of adding a colliding
-one-sided projection. The opposite appearance case still needs an explicit reset.
-The independent read-only re-review found no remaining concrete defect within the
-nine findings and these two subsets, including the immutable proposal/union/audit
-structure. That is scoped core review closure, not UI/API/spec release acceptance.
-
-Final Windows core evidence in D:/CodexBuilds/Capella2-semantic-review:
-
-```text
-cargo test --package oa-core --all-targets --locked --offline --config target/semantic/cargo.toml --target-dir D:/CodexBuilds/Capella2-semantic-target --no-fail-fast
-cargo clippy --package oa-core --all-targets --locked --offline --config target/semantic/cargo.toml --target-dir D:/CodexBuilds/Capella2-semantic-target -- -D warnings
-```
-
-Both exit0: 345 passed, 0 failed, 1 intentionally ignored inheritance scaling
-probe across 33 test executables; strict all-target Clippy has no warnings.
-Logs: target/semantic/core-final-all-tests.log and core-final-clippy.log. Focused
-immutable-proposals-artifact-focus.log contains 28 semantic and 7 source tests; the
-source suite includes real prepared writeback and included-file save/reopen. The
-catalog coverage unit checks every current model payload field's closed capture
-and write scope. These logs use the distinct semantic-target and vendored config.
-
-Native input remains paused following the user's physical stop. Root must handle
-resumed native authorization and integrated acceptance; the broader goal is active.
-
-Native input is paused after physical Escape; no R6 native trial has run.
 Root exclusively owns native input. Latest saved Windows trial is window1706782,
 ui-state-navigation-windows,49objects/28links/1 expected missing-owner warning.
 Linux navigation trial3148598 closed normally, exec46107 exit0; baseline Linux

harness/TASK_LEDGER.md

@@ -1,6 +1,6 @@
 # Task Ledger — first release
 
-Authoritative objective: attachment10134df9-bea2-4c02-a820-67b53d6b86f7/
+Authoritative objective: attachment07aee762-7d27-4cbe-81c3-2e82c7170711/
 goal-objective.md, read fully2026-09-06. STATE.md records execution; PLAN.md retains
 scope; DECISIONS.md and linked contracts preserve rationale.
 
@@ -39,9 +39,6 @@ requires native workflows, semantic evaluators and fresh independent review.
   whole-model equality or flat reformatting. Independent counterexamples were fixed.
 - R3 existing-target reconciliation remains name/description only. R6 data shape
   expansion is active implementation, not accepted functionality.
-- R6 core/source and actual HTTP semantics pass focused Windows and full Linux
-  core checks; desktop257 tests pass after independent draft/path/paging fixes.
-  Native R6 acceptance and bounded scenario-value authoring remain outstanding.
 
 ## Assumptions and open questions
 
@@ -52,10 +49,7 @@ requires native workflows, semantic evaluators and fresh independent review.
 - Routing offers a usable initial path plus manual pins; arbitrary dense diagrams
   are not guaranteed crossing-free. Measured dense full solve119ms remains a limit.
 - R3 typed historical bodies plus finite proposals appear simpler than a separate
-  recursive semantic-value schema. An isolated probe supports scalar partial review
-  and deleted historical references, but ordered membership/order acknowledgements
-  need separate typed order checkpoints. Historical source reference parsing is
-  still unimplemented; this remains a candidate awaiting independent review.
+  recursive semantic-value schema. This candidate awaits R6 freeze and review.
 
 ## Decisions and current strategy