Merge pull request #20 from stlab:sean-parent/planner-pre-claim-flood-fill

fix: extend planner to handle multi-input constraints via pre-claiming

Author: sean-parent

CLAUDE.md

@@ -53,6 +53,9 @@ git checkout -b <username>/<feature-name>
 
 Never commit directly to `main`.
 
+Before creating a PR, run the full check suite locally (fmt, clippy, and test from the
+Commands section above).
+
 ## Project Status
 
 This project has not been released yet and has no clients. The API is not stable and may change at

property-model/src/planner.rs

@@ -9,6 +9,15 @@
 //! at most one method per relationship can be eligible at any given point (the inputs of
 //! each method are the outputs of the other methods), so selection is deterministic.
 //!
+//! **Pre-claiming**: when a determined cell eliminates all but one feasible method for a
+//! relationship (a method is infeasible if it would overwrite a determined or pre-claimed
+//! cell), that sole method's outputs are *pre-claimed*: they can never become sources, even
+//! before all of the method's inputs are determined. Excluding pre-claimed outputs from
+//! feasibility prevents a method whose output is pre-claimed by the current flood-fill pass
+//! from being counted as a second viable option. This allows the planner to correctly handle
+//! constraints where the highest-strength cell is one of several inputs to the selected
+//! method.
+//!
 //! Because a method is only selected once all its inputs are determined, any method that
 //! writes an input to a later method necessarily appears earlier in the selection order.
 //! The selection order is therefore already a valid topological execution order.
@@ -43,14 +52,15 @@ pub(crate) fn plan(
     relationships: &SlotMap<RelationshipId, RelationshipData>,
 ) -> Result<Plan, Error> {
     let mut determined: HashSet<CellId> = HashSet::new();
+    let mut pre_claimed: HashSet<CellId> = HashSet::new();
     let mut selected: Vec<(RelationshipId, usize)> = Vec::new();
     let mut selected_set: HashSet<RelationshipId> = HashSet::new();
 
     let mut cells_sorted: Vec<CellId> = cells.keys().collect();
     cells_sorted.sort_by_key(|&id| Reverse(cells[id].strength));
 
     for &source in &cells_sorted {
-        if determined.contains(&source) {
+        if determined.contains(&source) || pre_claimed.contains(&source) {
             continue;
         }
         determined.insert(source);
@@ -77,10 +87,37 @@ pub(crate) fn plan(
                     );
                     for &output in &method.outputs {
                         determined.insert(output);
+                        pre_claimed.remove(&output);
                         queue.push_back(output);
                     }
                     selected_set.insert(rel_id);
                     selected.push((rel_id, method_idx));
+                } else {
+                    // No method is immediately selectable. If exactly one method remains
+                    // feasible — meaning no other method can run without overwriting a cell
+                    // that is already determined or pre-claimed — and the current cell is
+                    // one of its inputs, the flow continues along that method: pre-claim its
+                    // outputs and enqueue them so the flood-fill propagates further.
+                    //
+                    // Both `determined` and `pre_claimed` are excluded from feasibility so
+                    // that a method whose output is pre-claimed by this same flood-fill pass
+                    // is not counted as a second viable option.
+                    let mut feasible = rel.methods.iter().filter(|m| {
+                        m.outputs
+                            .iter()
+                            .all(|o| !determined.contains(o) && !pre_claimed.contains(o))
+                    });
+                    let first = feasible.next();
+                    let second = feasible.next();
+                    if let (Some(sole), None) = (first, second)
+                        && sole.inputs.contains(&cell)
+                    {
+                        for &output in &sole.outputs {
+                            if pre_claimed.insert(output) {
+                                queue.push_back(output);
+                            }
+                        }
+                    }
                 }
             }
         }

property-model/tests/integration.rs

@@ -1,5 +1,7 @@
 //! End-to-end integration tests for the property-model crate.
 
+use std::any::TypeId;
+
 use property_model::{Error, Method, Sheet};
 
 #[test]
@@ -163,3 +165,37 @@ fn mutually_dependent_relationships_return_conflict() {
 
     assert!(matches!(sheet.propagate(), Err(Error::Conflict)));
 }
+
+#[test]
+fn arity_3_2_1() {
+    let mut sheet = Sheet::new();
+    let a = sheet.add_cell("a".to_string());
+    let c = sheet.add_cell("ab".to_string());
+    let b = sheet.add_cell("b".to_string());
+    sheet
+        .add_relationship(vec![
+            Method::from_fn_2_1([a, b], c, |x: &String, y: &String| Ok(x.clone() + y)),
+            Method::new(
+                vec![c],
+                vec![a, b],
+                vec![TypeId::of::<String>()],
+                vec![TypeId::of::<String>(), TypeId::of::<String>()],
+                |args| {
+                    let z = args[0]
+                        .downcast_ref::<String>()
+                        .expect("type checked at add_relationship");
+                    let mut chars = z.chars();
+                    let first = chars.next().unwrap_or_default().to_string();
+                    let rest = chars.collect::<String>();
+                    Ok(vec![Box::new(first), Box::new(rest)])
+                },
+            ),
+        ])
+        .unwrap();
+
+    sheet.propagate().unwrap();
+
+    assert_eq!(sheet.read::<String>(a).unwrap(), "a");
+    assert_eq!(sheet.read::<String>(b).unwrap(), "b");
+    assert_eq!(sheet.read::<String>(c).unwrap(), "ab");
+}