@@ -4,6 +4,17 @@ import 'dart:math' as math;
 const String _kPushChars =
     '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz';
 
+/// Timestamp of the most recently generated ID. Kept at library level so
+/// that consecutive calls within the same millisecond can detect the
+/// collision and increment [_lastRandomSuffix] instead of re-rolling it.
+int _lastPushTime = 0;
+
+/// Random suffix of the most recently generated ID, as indices into
+/// [_kPushChars].
+final List<int> _lastRandomSuffix = List<int>.filled(12, 0);
+
+final math.Random _random = math.Random.secure();
+
 /// Implementation from https://gist.github.com/mikelehen/3596a30bd69384624c11
 ///
 /// Fancy ID generator that creates 20-character string identifiers with the following properties:
@@ -15,26 +26,30 @@ const String _kPushChars =
 ///    latter ones will sort after the former ones.  We do this by using the previous random bits
 ///    but "incrementing" them by 1 (only in the case of a timestamp collision).
 String generateId() {
-  int lastPushTime = 0;
-  final List<int> randomSuffix = List.filled(12, 0);
-  final math.Random random = math.Random.secure();
-
   final int now = DateTime.now().toUtc().millisecondsSinceEpoch;
   String id = _toPushIdBase64(now, 8);
 
-  if (now != lastPushTime) {
+  if (now != _lastPushTime) {
     for (int i = 0; i < 12; i += 1) {
-      randomSuffix[i] = random.nextInt(63);
+      _lastRandomSuffix[i] = _random.nextInt(_kPushChars.length);
     }
   } else {
+    // Same millisecond: increment the previous suffix by one (base-N with
+    // carry) so this ID sorts strictly after the previous one.
     int i;
-    for (i = 11; i >= 0 && randomSuffix[i] == 62; i--) {
-      randomSuffix[i] = 0;
+    for (
+      i = 11;
+      i >= 0 && _lastRandomSuffix[i] == _kPushChars.length - 1;
+      i--
+    ) {
+      _lastRandomSuffix[i] = 0;
     }
-    randomSuffix[i] += 1;
+    _lastRandomSuffix[i] += 1;
   }
-  final String suffixStr = randomSuffix.map((int i) => _kPushChars[i]).join();
-  lastPushTime = now;
+  final String suffixStr = _lastRandomSuffix
+      .map((int i) => _kPushChars[i])
+      .join();
+  _lastPushTime = now;
 
   return '$id$suffixStr';
 }
 
@@ -172,8 +172,9 @@ class NodeProcessor {
   /// This function will take the [internalConstraints] and union them to the
   /// [constraints] field to get a reinforced set of constraints.
   ///
-  /// This function is recursive and may travel up the parent tree from the
-  /// internal [BaseNode.relegatedConstraintsToChildren] function.
+  /// The parent's [BaseNode.relegatedConstraintsToChildren] for this node, if
+  /// any, are also unioned in (e.g. a ListTile's minimum leading width, a
+  /// ListView's item extent, or a GridView's cell size).
   static BoxConstraintsModel resolveConstraints(
     BaseNode node, {
     SizeFit? horizontalFit,
@@ -189,7 +190,7 @@ class NodeProcessor {
       final BoxConstraintsModel? relegatedConstraints = parent
           .relegatedConstraintsToChildren(node);
       if (relegatedConstraints != null) {
-        resolved = resolved.union(resolved);
+        resolved = resolved.union(relegatedConstraints);
       }
     }
 
 
@@ -0,0 +1,21 @@
+import 'package:codelessly_api/codelessly_api.dart';
+import 'package:test/test.dart';
+
+void main() {
+  test('IDs generated in a tight loop are unique and strictly increasing', () {
+    final List<String> ids = List<String>.generate(10000, (_) => generateId());
+
+    expect(ids.toSet(), hasLength(ids.length));
+    for (int i = 1; i < ids.length; i++) {
+      expect(
+        ids[i].compareTo(ids[i - 1]),
+        greaterThan(0),
+        reason: '${ids[i]} should sort after ${ids[i - 1]}',
+      );
+    }
+  });
+
+  test('IDs are 20 characters', () {
+    expect(generateId(), hasLength(20));
+  });
+}
@@ -0,0 +1,63 @@
+import 'package:codelessly_api/codelessly_api.dart';
+import 'package:test/test.dart';
+
+/// [NodeProcessor.resolveConstraints] must union the parent's
+/// [BaseNode.relegatedConstraintsToChildren] into the child's resolved
+/// constraints. It used to union the child's constraints with themselves,
+/// so a ListTile's minimum leading width or a ListView's item extent never
+/// reached the child.
+void main() {
+  final Map<String, BaseNode> nodes = <String, BaseNode>{};
+
+  setUp(() {
+    nodes.clear();
+    NodeProcessor.registerNodeGetter((String id) => nodes[id]!);
+  });
+
+  RectangleNode child(String parentID, {BoxConstraintsModel? constraints}) {
+    final RectangleNode node = RectangleNode(
+      id: 'child',
+      name: 'child',
+      basicBoxLocal: NodeBox(0, 0, 10, 10),
+      constraints: constraints ?? const BoxConstraintsModel(),
+    );
+    node.parentID = parentID;
+    nodes[node.id] = node;
+    return node;
+  }
+
+  test('a ListTile relegates its minLeadingWidth to the leading node', () {
+    final RectangleNode leading = child('tile');
+    nodes['tile'] = ListTileNode(
+      id: 'tile',
+      name: 'tile',
+      basicBoxLocal: NodeBox(0, 0, 300, 65),
+      leading: leading.id,
+      properties: ListTileProperties(minLeadingWidth: 56),
+      children: <String>[leading.id],
+    );
+
+    final BoxConstraintsModel resolved = NodeProcessor.resolveConstraints(
+      leading,
+    );
+    expect(resolved.minWidth, 56);
+  });
+
+  test('a ListView caps its children at the item extent', () {
+    final RectangleNode item = child(
+      'list',
+      constraints: const BoxConstraintsModel(maxHeight: 200),
+    );
+    nodes['list'] = ListViewNode(
+      id: 'list',
+      name: 'list',
+      basicBoxLocal: NodeBox(0, 0, 300, 400),
+      properties: ListViewProperties(itemExtent: 80),
+      children: <String>[item.id],
+    );
+
+    final BoxConstraintsModel resolved = NodeProcessor.resolveConstraints(item);
+    // The tighter of the child's own max (200) and the relegated one (80).
+    expect(resolved.maxHeight, 80);
+  });
+}