[nan-yu]

What was quadratic

Under a ValidationConfig that defers the graph checks (dangling references allowed, plus orphans or a missing root allowed, as an agent's renderer state configures it), the Dart core already checks each updateComponents against what it changes, through ComponentGraphBound (#3314, renamed in #3328). The composition check did not. When any catalog of the surface declares allowedParents or allowedChildren, MessageProcessor serialized every stored component and checked every edge of the surface on each message. A Column whose catalog declares allowedChildren, listing all its children up front and then receiving one child per message, cost time quadratic in the number of children.

The fix

When the graph check started from what the check before found, the surface passed the composition check of the batch before, so only the edges this batch changes need checking. This follows the holding split of the Python (#3326) and TypeScript (#3327) cores:

• A component of the batch is checked against the surface (when it is the root) and all of its children, as before.
• A component outside the batch that references a component of the batch keeps its other children, so only its edges to the batch components it holds are checked. The bound's parent index gives those holders.
• Every other edge is unchanged and passed before.

The Dart composition check works edge by edge, with no check that a component has a parent, so a child that a batch component referenced before, or references now, needs no separate check of its parents: the edges that remain are checked with the batch component, and a dropped edge cannot fail.

The shortcut is taken only when the default catalog is the only one declaring constraints. The constraints are then that catalog's, and every earlier check applied them first, so the surface passed them. Otherwise, or when the graph check walked the whole graph, the whole surface is checked as before. A batch the shortcut rejects is checked again against the whole surface, so the error raised, its message and its path are those of the whole-surface check. Strict configs are unaffected.

checkComponentsUpdate now returns the bound when it used it, and ComponentGraphBound gains parentsOf. The edge and root checks of checkCompositionConstraints move into helpers shared with the new compositionHoldsAfter.

Tests

• composition_constraints_test.dart sends each batch to two processors under the same deferred config (missing root allowed, and orphans allowed). The second has a component touched after each batch, so it always checks the whole surface. The two must raise the same error (type, code, path, message) and hold the same components. Cases: a child that arrives after its container, a container that arrives after its child, a child added to a container in a later message, a container rewritten to drop a disallowed child, a held child whose type changes, a holder that a child's allowedParents omits, a root the surface may not hold, and 200 random sequences of 20 batches per config. Skipping the holder edges, or the batch components' checks, makes several of these fail.
• composition_scaling_test.dart is a performance-tagged test, run by dart test -P performance, timing the allowedChildren Column case at 500 and 2000 children with a maximum ratio of 8. The timing helpers move from the shared scaling suite's test into test/support/timing.dart so both use them.

Median times (5 runs each, 3 runs of the test):

	500 children	2000 children	ratio
main	~147 ms	~2240 ms	14.53 / 15.75 / 15.69
this PR	~17 ms	~70 ms	2.19 / 4.19 / 4.29

The case is not added to the shared conformance/core/message_processor_scaling.yaml, since the Python and TypeScript cores on main would fail it. Once #3326, #3327 and this PR land, it can move into the shared suite.

[gemini-code-assist]

Code Review

This pull request optimizes the composition constraint checks in MessageProcessor under a deferred validation config. Instead of checking the entire graph, it now incrementally checks only the edges changed by an update batch, significantly improving performance when children are added one by one. The changes include refactoring checkCompositionConstraints to extract helper validation methods, introducing compositionHoldsAfter to verify changed edges, updating checkComponentsUpdate to return the graph bound, and moving timing test utilities to a shared support file. Comprehensive unit and performance tests have been added to verify correctness and scaling. I have no feedback to provide as there are no review comments.