@@ -1045,8 +1045,9 @@ mixin PropertyVariableMixin on BaseNode {
   /// Properties of the node that can be used in actions or can be changed by
   /// an action.
   ///
-  /// Style properties (fill, stroke, opacity, width, height; a text's fill is
-  /// its color) can be set by
+  /// Style properties (fill, stroke, opacity, width, height, effectsVisible,
+  /// strokeWeight, cornerRadius; a text's fill is its color, and its
+  /// fontWeight a number from 100 to 900) can be set by
   /// conditions, bound to variables or formulas, or changed by a set value
   /// action, on any node that has them.
   late final List<ValueModel> propertyVariables = [
@@ -1056,13 +1057,30 @@ mixin PropertyVariableMixin on BaseNode {
       PaintValue(name: 'fill', value: geometry.fills.firstOrNull),
       PaintValue(name: 'stroke', value: geometry.strokes.firstOrNull),
     ],
-    if (this case final TextNode text)
+    if (this case final TextNode text) ...[
       PaintValue(
         name: 'fill',
         value: text.textMixedProps.firstOrNull?.fills.firstOrNull,
       ),
-    if (this case final BlendMixin blend)
+      IntValue(
+        name: 'fontWeight',
+        value:
+            ((text.textMixedProps.firstOrNull?.fontName.weight?.index ?? 3) +
+                1) *
+            100,
+      ),
+    ],
+    if (this case final BlendMixin blend) ...[
       DoubleValue(name: 'opacity', value: blend.opacity),
+      BoolValue(
+        name: 'effectsVisible',
+        value: blend.effects.every((effect) => effect.visible),
+      ),
+    ],
+    if (this case final GeometryMixin geometry)
+      DoubleValue(name: 'strokeWeight', value: geometry.strokeWeight),
+    if (this case final CornerMixin corner)
+      DoubleValue(name: 'cornerRadius', value: corner.cornerRadius.tl.x),
     DoubleValue(name: 'width', value: basicBoxLocal.width),
     DoubleValue(name: 'height', value: basicBoxLocal.height),
   ];
 
@@ -190,6 +190,18 @@ class EdgeInsetsModel with Equatable, DynamicSerializableMixin {
 
   /// Factory constructor for creating a new [EdgeInsetsModel] instance
   /// from JSON data.
+  static const Set<String> _longSideKeys = <String>{
+    'left',
+    'top',
+    'right',
+    'bottom',
+    'horizontal',
+    'vertical',
+  };
+
+  static double _side(Map<dynamic, dynamic> json, String side, String axis) =>
+      ((json[side] ?? json[axis] ?? 0) as num).toDouble();
+
   factory EdgeInsetsModel.fromJson(dynamic json) {
     return switch (json) {
       num all => EdgeInsetsModel.all(all.toDouble()),
@@ -203,6 +215,15 @@ class EdgeInsetsModel with Equatable, DynamicSerializableMixin {
         right: right.toDouble(),
         bottom: bottom.toDouble(),
       ),
+      // Spelled-out sides, as Flutter names them; missing sides are 0.
+      Map<dynamic, dynamic> sides
+          when sides.keys.any(_longSideKeys.contains) =>
+        EdgeInsetsModel.only(
+          left: _side(sides, 'left', 'horizontal'),
+          top: _side(sides, 'top', 'vertical'),
+          right: _side(sides, 'right', 'horizontal'),
+          bottom: _side(sides, 'bottom', 'vertical'),
+        ),
       _ => _$EdgeInsetsModelFromJson(json),
     };
   }
 
@@ -201,6 +201,33 @@ class ListViewProperties extends CustomProperties with FieldsHolder {
   /// with motion bound to their index (see [MotionModel]).
   bool stacked;
 
+  /// Whether the items flow onto further lines (runs) when they don't fit,
+  /// like Flutter's [Wrap], instead of scrolling in one line. The scroll
+  /// direction is the wrap direction: a horizontal list fills a line from
+  /// left to right, then starts a new line below; a vertical list fills a
+  /// column top to bottom, then starts a new column to the right. Items keep
+  /// their own size (they are not stretched to the list's cross extent).
+  /// Separators are not drawn; use [wrapSpacing] and [wrapRunSpacing].
+  /// Ignored when [stacked] is true.
+  ///
+  /// A wrapping list shows every item, so it needs an item count or a data
+  /// source. It scrolls along the cross axis when its runs don't fit its box;
+  /// give it a shrink-wrap fit on the cross axis to grow with its runs.
+  bool wrap;
+
+  /// The gap between two items of the same line when [wrap] is true.
+  double wrapSpacing;
+
+  /// The gap between two lines (runs) when [wrap] is true.
+  double wrapRunSpacing;
+
+  /// How the items of a line are placed along the wrap direction when [wrap]
+  /// is true. Maps to Flutter's [WrapAlignment] by name.
+  MainAxisAlignmentC wrapAlignment;
+
+  /// Whether this list wraps its items: [wrap] is on and [stacked] is off.
+  bool get isWrapping => wrap && !stacked;
+
   /// Creates a new [ListViewProperties] instance.
   ListViewProperties({
     this.itemCount,
@@ -210,6 +237,10 @@ class ListViewProperties extends CustomProperties with FieldsHolder {
     this.separatorSpacing = 0,
     this.hasSeparator = false,
     this.stacked = false,
+    this.wrap = false,
+    this.wrapSpacing = 0,
+    this.wrapRunSpacing = 0,
+    this.wrapAlignment = MainAxisAlignmentC.start,
     DividerProperties? dividerProperties,
   }) : dividerProperties = dividerProperties ?? DividerProperties();
 
@@ -230,10 +261,18 @@ class ListViewProperties extends CustomProperties with FieldsHolder {
     double? dividerSpacing,
     bool? hasSeparator,
     bool? stacked,
+    bool? wrap,
+    double? wrapSpacing,
+    double? wrapRunSpacing,
+    MainAxisAlignmentC? wrapAlignment,
     DividerProperties? dividerProperties,
   }) {
     return ListViewProperties(
       stacked: stacked ?? this.stacked,
+      wrap: wrap ?? this.wrap,
+      wrapSpacing: wrapSpacing ?? this.wrapSpacing,
+      wrapRunSpacing: wrapRunSpacing ?? this.wrapRunSpacing,
+      wrapAlignment: wrapAlignment ?? this.wrapAlignment,
       itemCount: itemCount ?? this.itemCount,
       itemExtent: itemExtent ?? this.itemExtent,
       cacheExtent: cacheExtent ?? this.cacheExtent,
@@ -255,6 +294,37 @@ class ListViewProperties extends CustomProperties with FieldsHolder {
       (value) => stacked = value,
       requiresLayout: true,
     ),
+    'wrap': BoolFieldAccess(
+      'Wrap',
+      'Flow the items onto further lines when they do not fit, instead of '
+          'scrolling in one line. Ignored when Stacked is on.',
+      () => wrap,
+      (value) => wrap = value,
+      requiresLayout: true,
+    ),
+    'wrapSpacing': NumFieldAccess<double>(
+      'Wrap Spacing',
+      'The gap between two items of the same line of a wrapping list.',
+      () => wrapSpacing,
+      (value) => wrapSpacing = value,
+      requiresLayout: true,
+    ),
+    'wrapRunSpacing': NumFieldAccess<double>(
+      'Wrap Run Spacing',
+      'The gap between two lines of a wrapping list.',
+      () => wrapRunSpacing,
+      (value) => wrapRunSpacing = value,
+      requiresLayout: true,
+    ),
+    'wrapAlignment': EnumFieldAccess<MainAxisAlignmentC>(
+      'Wrap Alignment',
+      'How the items of a line of a wrapping list are placed along it.',
+      () => wrapAlignment,
+      (value) => wrapAlignment = value,
+      defaultValue: () => MainAxisAlignmentC.start,
+      options: () => MainAxisAlignmentC.values,
+      requiresLayout: true,
+    ),
     'hasSeparator': BoolFieldAccess(
       'Has Separator',
       'Whether to use a separator between list view items.',
@@ -304,6 +374,10 @@ class ListViewProperties extends CustomProperties with FieldsHolder {
     separatorSpacing,
     hasSeparator,
     stacked,
+    wrap,
+    wrapSpacing,
+    wrapRunSpacing,
+    wrapAlignment,
     dividerProperties,
   ];
 }
@@ -0,0 +1,31 @@
+import 'package:codelessly_api/codelessly_api.dart';
+import 'package:test/test.dart';
+
+void main() {
+  test('padding reads spelled-out sides', () {
+    expect(
+      EdgeInsetsModel.fromJson({'left': 1, 'top': 2, 'right': 3, 'bottom': 4}),
+      EdgeInsetsModel.only(left: 1, top: 2, right: 3, bottom: 4),
+    );
+    expect(
+      EdgeInsetsModel.fromJson({'horizontal': 16, 'vertical': 8}),
+      EdgeInsetsModel.symmetric(horizontal: 16, vertical: 8),
+    );
+    expect(
+      EdgeInsetsModel.fromJson({'top': 12}),
+      EdgeInsetsModel.only(top: 12),
+    );
+  });
+
+  test('the stored forms still read', () {
+    expect(EdgeInsetsModel.fromJson(8), EdgeInsetsModel.all(8));
+    expect(
+      EdgeInsetsModel.fromJson([1, 2, 3, 4]),
+      EdgeInsetsModel.only(left: 1, top: 2, right: 3, bottom: 4),
+    );
+    expect(
+      EdgeInsetsModel.fromJson({'l': 1, 't': 2, 'r': 3, 'b': 4}),
+      EdgeInsetsModel.only(left: 1, top: 2, right: 3, bottom: 4),
+    );
+  });
+}
@@ -0,0 +1,43 @@
+import 'package:codelessly_api/codelessly_api.dart';
+import 'package:test/test.dart';
+
+void main() {
+  test('wrap settings survive JSON and are omitted at their defaults', () {
+    expect(ListViewProperties().toJson().keys,
+        isNot(anyOf(contains('wrap'), contains('wrapSpacing'),
+            contains('wrapRunSpacing'), contains('wrapAlignment'))));
+
+    final ListViewProperties props = ListViewProperties(
+      wrap: true,
+      wrapSpacing: 8,
+      wrapRunSpacing: 6,
+      wrapAlignment: MainAxisAlignmentC.center,
+    );
+    final Map<String, dynamic> json = props.toJson();
+    expect(json['wrap'], isTrue);
+    expect(json['wrapSpacing'], 8);
+    expect(json['wrapRunSpacing'], 6);
+    expect(json['wrapAlignment'], 'center');
+
+    final ListViewProperties copy = ListViewProperties.fromJson(json);
+    expect(copy, props);
+    expect(copy.isWrapping, isTrue);
+    expect(props.copyWith(), props);
+    expect(props.copyWith(stacked: true).isWrapping, isFalse);
+  });
+
+  test('a wrapping list node round-trips', () {
+    final ListViewNode node = ListViewNode(
+      id: 'list',
+      name: 'Crates',
+      basicBoxLocal: NodeBox(0, 0, 300, 40),
+      properties: ListViewProperties(wrap: true, wrapSpacing: 4),
+      children: const [],
+      scrollDirection: AxisC.horizontal,
+    );
+    final ListViewNode copy = ListViewNode.fromJson(node.toJson());
+    expect(copy.properties.wrap, isTrue);
+    expect(copy.properties.wrapSpacing, 4);
+    expect(copy.scrollDirection, AxisC.horizontal);
+  });
+}
@@ -0,0 +1,55 @@
+import 'package:codelessly_api/codelessly_api.dart';
+import 'package:test/test.dart';
+
+void main() {
+  test('A shape offers its effects, stroke weight and corner radius to set '
+      'value actions', () {
+    final RectangleNode node = RectangleNode(
+      id: 'chip',
+      name: 'Chip',
+      basicBoxLocal: NodeBox(0, 0, 80, 32),
+      strokeWeight: 2,
+      cornerRadius: const CornerRadius.all(RadiusModel.circular(6)),
+      effects: [
+        Effect.dropShadow(
+          id: 'shadow',
+          visible: false,
+          radius: 0,
+          color: ColorRGBA.black,
+          offset: const Vec(2, 2),
+          spread: 0,
+        ),
+      ],
+    );
+    final Map<String, Object?> values = {
+      for (final ValueModel value in node.propertyVariables)
+        value.name: value.value,
+    };
+    expect(values['effectsVisible'], isFalse);
+    expect(values['strokeWeight'], 2);
+    expect(values['cornerRadius'], 6);
+  });
+
+  test('A text offers its font weight as a number', () {
+    final TextNode node = TextNode(
+      id: 'text',
+      name: 'Text',
+      basicBoxLocal: NodeBox(0, 0, 80, 20),
+      characters: 'Oat',
+      textMixedProps: [
+        StartEndProp(
+          start: 0,
+          end: 3,
+          fontName: const FontName(
+            family: 'Roboto',
+            weight: FontWeightNumeric.w700,
+          ),
+        ),
+      ],
+    );
+    final ValueModel weight = node.propertyVariables.firstWhere(
+      (value) => value.name == 'fontWeight',
+    );
+    expect(weight.value, 700);
+  });
+}