fix(runtime): = values in action, calc, block and state bodies hold at all times

changes/unreleased/body-feature-bindings.fixed.md

@@ -0,0 +1 @@
+- **Track `=` values in action, calculation, statement-block, and state-machine bodies.** Their dependencies are re-evaluated when read after a source changes, while `:=`, `default`, and values assigned to a binding retain their existing write behavior. An unsupplied inherited action parameter such as `z = x * 2` now follows a later write to `x` (`action_inherited_default_root`: `z` and `r` change from 6 to 20); the supplied argument in `action_inherited_supplied_parameter` remains held. Body-local calc usages remain evaluated once per declaration. Explore/check now agrees on the shared-writers `=` case with `{3}` rather than `{1,2,3}`.

changes/unreleased/case-bindings-unvalued-mark.fixed.md

@@ -0,0 +1,4 @@
+- **A case-local a run left declared without a value stays unvalued in the frame its conditions
+  read.** `frame.markUnvalued` allocated its map on a copy of the frame, so a mark on a frame that
+  held no unvalued name yet was lost, and an objective or assertion naming such a local could read
+  through to a binding of the same name instead of being undecided for the missing value.

internal/exec/runtime/action_executor.go

@@ -301,6 +301,7 @@ func (e *ActionExecutor) performanceFeatures() []lower.Attribute {
 		features = append(features, lower.Attribute{
 			Name: name, Direction: usage.Direction, IsResult: usage.IsResult, Type: lower.TypeText(usage),
 			Value: value, Node: usage, Scope: scope, Optional: e.ctx.admitsNoValue(member),
+			Binding: value != nil && !usage.ValueIsInitial && !usage.ValueIsDefault,
 		})
 	}
 	return features
@@ -1313,8 +1314,21 @@ func (e *ActionExecutor) initializeAttributes() error {
 				return fmt.Errorf("%w: read %s of object #%d: %w",
 					ErrActionPerformanceOccurrence, attr.Name, e.occurrence.ID, err)
 			}
-			if value := fv.HeldValue(); value.Kind != ValInvalid {
-				e.root.data[e.root.key(attr.Name)] = value
+			if attr.Binding && !fv.Written && !e.occurrenceRedefinesAttribute(attr, fv) {
+				value, seeded, err := e.ctx.seedBodyBindingFromFeatureValue(e.root.cells, e.root.key(attr.Name), fv)
+				if err != nil {
+					return fmt.Errorf("eval attribute default %s: %w", attr.Name, err)
+				}
+				if seeded {
+					if err := e.streamInitialOutput(attr.Name, value); err != nil {
+						return err
+					}
+					continue
+				}
+			}
+			if value := fv.HeldValue(); value.Kind != ValInvalid &&
+				(!attr.Binding || fv.Written || e.occurrenceRedefinesAttribute(attr, fv)) {
+				e.ctx.writeBodyValue(e.root.cells, e.root.data, e.root.key(attr.Name), value)
 				if err := e.streamInitialOutput(attr.Name, value); err != nil {
 					return err
 				}
@@ -1327,17 +1341,29 @@ func (e *ActionExecutor) initializeAttributes() error {
 			}
 			continue
 		}
-		value, err := evalDefaults().evalIn(attr.Scope).Eval(attr.Value)
+		var value Value
+		var err error
+		if attr.Binding {
+			value, err = e.ctx.deriveBodyCell(
+				e.root.cells, e.root.key(attr.Name), e.root.cells.existingCell(e.root.key(attr.Name)),
+			)
+		} else {
+			value, err = evalDefaults().evalIn(attr.Scope).Eval(attr.Value)
+		}
 		if err != nil {
 			return fmt.Errorf("eval attribute default %s: %w", attr.Name, err)
 		}
 		if err := e.holdAttributeAsReal(attr, &value); err != nil {
 			return fmt.Errorf("eval attribute default %s: %w", attr.Name, err)
 		}
-		if value, err = e.mirrorOccurrence(attr.Name, value); err != nil {
-			return err
+		if !attr.Binding {
+			if value, err = e.mirrorOccurrence(attr.Name, value); err != nil {
+				return err
+			}
+		}
+		if !attr.Binding {
+			e.ctx.writeBodyValue(e.root.cells, e.root.data, e.root.key(attr.Name), value)
 		}
-		e.root.data[e.root.key(attr.Name)] = value
 		if err := e.streamInitialOutput(attr.Name, value); err != nil {
 			return err
 		}
@@ -1384,7 +1410,7 @@ func (e *ActionExecutor) bindContextDefault(attr lower.Attribute) bool {
 	if err != nil {
 		return false
 	}
-	e.root.data[e.root.key(attr.Name)] = value
+	e.ctx.writeBodyValue(e.root.cells, e.root.data, e.root.key(attr.Name), value)
 	return true
 }
 
@@ -1430,16 +1456,23 @@ func (e *ActionExecutor) materializeOccurrence() (*Instance, error) {
 	if err != nil {
 		return nil, err
 	}
+	e.occurrence = inst
+	e.performances.occurrence = inst
 	for _, attr := range e.features {
 		if value, held := e.root.data[e.root.key(attr.Name)]; held {
+			if cell := e.root.cells.existingCell(e.root.key(attr.Name)); cell != nil && cell.binding != nil && !cell.fv.Written {
+				if _, err := e.mirrorBindingOccurrence(attr.Name, value, cell); err != nil {
+					return nil, fmt.Errorf("%w: seed %s of object #%d: %w",
+						ErrActionPerformanceOccurrence, attr.Name, inst.ID, err)
+				}
+				continue
+			}
 			if err := inst.BindFeatureValue(e.ctx, attr.Name, value); err != nil {
 				return nil, fmt.Errorf("%w: seed %s of object #%d: %w",
 					ErrActionPerformanceOccurrence, attr.Name, inst.ID, err)
 			}
 		}
 	}
-	e.occurrence = inst
-	e.performances.occurrence = inst
 	e.ctx.beginPerformanceLife(inst, e.ctx.newActivation())
 	return inst, nil
 }
@@ -1477,6 +1510,24 @@ func (e *ActionExecutor) mirrorOccurrence(name string, value Value) (Value, erro
 	return fv.HeldValue(), nil
 }
 
+// mirrorBindingOccurrence exposes a tracked body feature through its occurrence.
+func (e *ActionExecutor) mirrorBindingOccurrence(name string, value Value, cell *bodyCell) (Value, error) {
+	if e.occurrence == nil || !e.declaresAttribute(name) {
+		return value, nil
+	}
+	mirrored, err := e.ctx.mirrorBodyCell(e.occurrence, name, cell, value)
+	if err != nil {
+		return value, fmt.Errorf("%w: write %s of object #%d: %w",
+			ErrActionPerformanceOccurrence, name, e.occurrence.ID, err)
+	}
+	return mirrored, nil
+}
+
+// occurrenceRedefinesAttribute reports whether the occurrence supplies another declaration's default.
+func (e *ActionExecutor) occurrenceRedefinesAttribute(attr lower.Attribute, fv *FeatureValue) bool {
+	return occurrenceHasRedefinedDefault(fv, attr, e.graph.Scope)
+}
+
 // setFeature writes into the action's feature space, through the performance
 // occurrence for a feature the action declares: the occurrence is authoritative
 // for those, and data mirrors what it holds after the write.
@@ -1491,7 +1542,7 @@ func (e *ActionExecutor) setFeature(name string, value Value) error {
 		// rather than by the write to that occurrence.
 		return err
 	}
-	e.root.data[e.root.key(name)] = value
+	e.ctx.writeBodyValue(e.root.cells, e.root.data, e.root.key(name), value)
 	e.moved = true
 	return e.streamOutput(name, value)
 }
@@ -1550,19 +1601,27 @@ func (e *ActionExecutor) hasFlow() bool {
 		e.dynamicsKind != lower.NotStateSpace)
 }
 
+// completeRoot freezes the root bindings and ends its performance.
+func (e *ActionExecutor) completeRoot() error {
+	if err := e.ctx.freezeBodyCells(e.root.cells); err != nil {
+		return err
+	}
+	e.state = StateCompleted
+	e.endRootPerformance()
+	return nil
+}
+
 // completeWithoutFlow completes an action stating no flow: it performs no step,
 // so its performance begins, takes its inputs, and ends at once.
 func (e *ActionExecutor) completeWithoutFlow() error {
 	if err := e.checkResultParameters(); err != nil {
 		return err
 	}
-	e.ctx.beginPerformanceLife(e.occurrence, e.ctx.newActivation())
+	e.beginRootPerformance()
 	if err := e.bindInputs(); err != nil {
 		return err
 	}
-	e.state = StateCompleted
-	e.ctx.endPerformanceLife(e.occurrence)
-	return nil
+	return e.completeRoot()
 }
 
 // bindInputs writes the supplied inputs into the performance, then the
@@ -1583,6 +1642,20 @@ func (e *ActionExecutor) bindInputs() error {
 	return nil
 }
 
+// beginRootPerformance starts the root performance's dependency lifetime.
+func (e *ActionExecutor) beginRootPerformance() {
+	if e.root.began == 0 {
+		e.root.began = e.ctx.newActivation()
+	}
+	e.ctx.beginPerformanceLife(e.occurrence, e.root.began)
+}
+
+// endRootPerformance ends the root performance's dependency lifetime.
+func (e *ActionExecutor) endRootPerformance() {
+	e.ctx.endPerformanceLife(e.occurrence)
+	e.ctx.endActivation(e.root.began)
+}
+
 type inputBindingError struct{ Err error }
 
 func (e inputBindingError) Error() string { return e.Err.Error() }
@@ -1699,7 +1772,7 @@ func (e *ActionExecutor) initialize() error {
 		return err
 	}
 
-	e.ctx.beginPerformanceLife(e.occurrence, e.ctx.newActivation())
+	e.beginRootPerformance()
 	if err := e.bindInputs(); err != nil {
 		return err
 	}
@@ -1710,9 +1783,7 @@ func (e *ActionExecutor) initialize() error {
 		if err := checkStreamsReceived(e.root); err != nil {
 			return err
 		}
-		e.state = StateCompleted
-		e.ctx.endPerformanceLife(e.occurrence)
-		return nil
+		return e.completeRoot()
 	}
 	e.seedTokens(e.root, starts, 0)
 
@@ -2261,8 +2332,7 @@ func (e *ActionExecutor) retireToken(tokenIdx int) error {
 			if err := checkStreamsReceived(e.root); err != nil {
 				return err
 			}
-			e.state = StateCompleted
-			e.ctx.endPerformanceLife(e.occurrence)
+			return e.completeRoot()
 		}
 		return nil
 	}
@@ -2600,7 +2670,7 @@ func (e *ActionExecutor) stepNestedAction(tokenIdx int) error {
 		}
 	}
 
-	perf, err := e.beginPerformance(token.frame, graph, usage, nil)
+	perf, err := e.beginPerformance(token.frame, graph, usage, nil, nil)
 	if err != nil {
 		return err
 	}
@@ -3319,10 +3389,17 @@ func (e *ActionExecutor) State() ExecutionState {
 // each nested non-repeated node's latest performance and under `part.attribute` what the one
 // object each of its own parts denotes holds; a performed usage's mirror its occurrence.
 func (e *ActionExecutor) Results() map[string]Value {
+	results, _ := e.ResultsWithError()
+	return results
+}
+
+// ResultsWithError returns the values the action's features hold and the first binding
+// derivation error; a feature whose binding fails to derive is omitted.
+func (e *ActionExecutor) ResultsWithError() (map[string]Value, error) {
 	results := make(map[string]Value, len(e.root.data))
-	e.root.collect("", results)
+	err := e.root.collect("", results)
 	e.collectPartsHeld(results)
-	return results
+	return results, err
 }
 
 // collectPartsHeld adds the attributes held by the object each part or item usage the