fix(map): write back transformed field values to parent table

cv_check_map iterated over properties, called cv_check_node
for each field (which applied transform via lua_replace on
the stack copy), but never wrote the result back into the
parent table. The transformed value was silently discarded.

cv_check_array already did this correctly via lua_rawseti.
Fix cv_check_map to match: after cv_check_node succeeds,
push val_idx and call cv_map_setfield to persist the
transformed value.

This also fixes the case where a oneof variant applies a
transform — the parent map's own transform now sees the
already-transformed field value, matching old validator
behaviour.

Add regression tests in test/check_test.lua:
- test_map_field_transform_writeback (scalar + oneof)
- test_array_item_transform_writeback (regression guard)
- test_array_item_transform_writeback_oneof (guard)

Author: unera

cv/cv.c

@@ -2863,6 +2863,14 @@ cv_check_map(lua_State *L, struct cv_ctx *ctx,
 		if (ctx->depth > 0)
 			ctx->depth--;
 
+		if (r && !ctx->validate_only) {
+			/* write back: cv_check_node may have
+			 * updated val_idx via transform */
+			lua_pushvalue(L, val_idx);
+			cv_map_setfield(L, data_idx,
+			    &pp->key);
+		}
+
 		lua_pop(L, 1); /* pop value */
 
 		if (!r) {

test/check_test.lua

@@ -537,4 +537,104 @@ g.test_enum_value_error = function()
         errs[1].details.enum_variants, 'table')
 end
 
+-- -------------------------------------------------------
+-- transform on map field must be written back
+-- -------------------------------------------------------
+
+-- Regression: transform applied to a map field must be
+-- written back into the parent table.
+-- Previously cv_check_node mutated the stack copy but
+-- never called cv_map_setfield to persist the change.
+g.test_map_field_transform_writeback = function()
+    -- simple scalar field with transform
+    local s = schema({
+        type = 'map',
+        properties = {
+            x = {
+                type = 'number',
+                transform = function(v)
+                    return v * 10
+                end,
+            },
+        },
+    })
+    local r, errs = s:check({x = 5})
+    t.assert_equals(errs, {})
+    t.assert_equals(r.x, 50)
+
+    -- oneof field with transform: parent map transform
+    -- must see the already-transformed child value
+    local seen_by_parent
+    local s2 = schema({
+        type = 'map',
+        properties = {
+            field = {
+                type = 'oneof',
+                variants = {
+                    {
+                        type = 'number',
+                        transform = function(v)
+                            return v * 2
+                        end,
+                    },
+                    'string',
+                },
+            },
+        },
+        transform = function(v)
+            seen_by_parent = v.field
+            return v
+        end,
+    })
+    local r2, errs2 = s2:check({field = 3})
+    t.assert_equals(errs2, {})
+    -- child transform: 3 -> 6
+    t.assert_equals(r2.field, 6)
+    -- parent transform must see the child result
+    t.assert_equals(seen_by_parent, 6)
+end
+
+-- -------------------------------------------------------
+-- transform on array items must be written back
+-- -------------------------------------------------------
+
+-- Verify that cv_check_array already correctly writes
+-- back transformed item values (regression guard).
+g.test_array_item_transform_writeback = function()
+    local s = schema({
+        type = 'array',
+        items = {
+            type = 'number',
+            transform = function(v)
+                return v * 10
+            end,
+        },
+    })
+    local r, errs = s:check({1, 2, 3})
+    t.assert_equals(errs, {})
+    t.assert_equals(r, {10, 20, 30})
+end
+
+-- array items via oneof with transform in matched variant
+g.test_array_item_transform_writeback_oneof = function()
+    local s = schema({
+        type = 'array',
+        items = {
+            type = 'oneof',
+            variants = {
+                {
+                    type = 'number',
+                    transform = function(v)
+                        return v * 2
+                    end,
+                },
+                'string',
+            },
+        },
+    })
+    local r, errs = s:check({3, 'hello', 5})
+    t.assert_equals(errs, {})
+    t.assert_equals(r, {6, 'hello', 10})
+end
+
 -- vim: ts=4 sts=4 sw=4 et