fix(mapper): keep all-zero arrays under omitempty (legacy behavior)

The previous fix-up rewrote the array branch to skip on fld.IsZero()
for both flags. That over-corrected: pre-omitzero, the original code's
else-if chain entered the Array|Slice arm and only set isZero on
Len()==0. Normal-length all-zero arrays ([16]byte UUIDs, [32]byte
hashes, ed25519 keys) were always emitted under omitempty.

Split the array branch so omitempty stays Len()==0 (matches legacy)
and omitzero gets the strict IsZero() rule (Go 1.24+ json semantic).

Tests:
- TestMap_OmitEmpty_AllZeroArray flipped to assert pre-PR behavior
  (all-zero [16]byte kept). Was previously asserting the regression.
- TestMap_OmitZero_AllZeroArray added for the strict-zero side.

Caught by an adversarial Codex pass on pgkit#50; the earlier
self-review traced the pre-PR else-if chain incorrectly and asked
for a "fix" that wasn't actually a regression.

Author: klaidliadon

mapper.go

@@ -131,8 +131,15 @@ func MapWithOptions(record interface{}, options *MapOptions) ([]string, []interf
 						isEmpty, isStrictZero = true, true
 					}
 				case reflect.Array:
+					// Legacy omitempty: only [0]T counted (Len==0). Normal-length
+					// all-zero arrays were emitted. Keep that — switching to
+					// IsZero for omitempty would silently drop [16]byte UUIDs,
+					// [32]byte hashes, etc. omitzero gets the strict rule.
+					if fld.Len() == 0 {
+						isEmpty = true
+					}
 					if fld.IsZero() {
-						isEmpty, isStrictZero = true, true
+						isStrictZero = true
 					}
 				default:
 					if reflect.DeepEqual(fi.Zero.Interface(), value) {

mapper_test.go

@@ -80,17 +80,32 @@ func TestMap_OmitEmpty_EmptyNonNilMap(t *testing.T) {
 }
 
 func TestMap_OmitEmpty_AllZeroArray(t *testing.T) {
-	// Regression guard: pre-omitzero behavior — omitempty skipped an
-	// all-zero array via the DeepEqual fallback (e.g. [32]byte{} hashes,
-	// [16]byte UUIDs). Keep that for fixed-size byte fields.
+	// Regression guard for legacy omitempty behavior: pre-omitzero, the
+	// array/slice branch only set isZero on Len()==0, which is only true
+	// for the degenerate [0]T. The else-if chain blocked the DeepEqual
+	// fallback, so a normal-length all-zero array ([16]byte UUIDs,
+	// [32]byte hashes) was ALWAYS emitted under omitempty. Preserve that.
 	type Record struct {
 		Hash [16]byte `db:"hash,omitempty"`
 	}
 	got := mapFields(t, &Record{})
-	assert.NotContains(t, got, "hash", "all-zero array skipped by omitempty")
+	assert.Contains(t, got, "hash", "all-zero array kept under omitempty (legacy)")
 
 	got = mapFields(t, &Record{Hash: [16]byte{1}})
-	assert.Contains(t, got, "hash", "non-zero array kept by omitempty")
+	assert.Contains(t, got, "hash", "non-zero array kept under omitempty")
+}
+
+func TestMap_OmitZero_AllZeroArray(t *testing.T) {
+	// omitzero IS the strict-zero option, so an all-zero fixed-size array
+	// is skipped here. Distinct from omitempty's array behavior above.
+	type Record struct {
+		Hash [16]byte `db:"hash,omitzero"`
+	}
+	got := mapFields(t, &Record{})
+	assert.NotContains(t, got, "hash", "all-zero array skipped under omitzero")
+
+	got = mapFields(t, &Record{Hash: [16]byte{1}})
+	assert.Contains(t, got, "hash", "non-zero array kept under omitzero")
 }
 
 func TestMap_OmitZero_NilSlice(t *testing.T) {