diff --git a/docs/roadmap/remediation.md b/docs/roadmap/remediation.md index bc9af1f..e29dc44 100644 --- a/docs/roadmap/remediation.md +++ b/docs/roadmap/remediation.md @@ -137,6 +137,11 @@ cancellation distinct. ### R4 — Preserve Effective Transcript Members During Typed Decoding (P3) +**Complete.** Each segment resolves duplicate keys before field conversion +and processes case variants in the baseline key order. The decoder keeps +numeric tokens intact. Schema tests cover superseded and effective type +mismatches, both case-variant orders, and exact IDs in both envelopes. + **Affected plan:** Stage 5, item 1. **Evidence:** The baseline selected the final value of an exact duplicate JSON diff --git a/internal/core/schema/transcript.go b/internal/core/schema/transcript.go index 92890cf..d2b9390 100644 --- a/internal/core/schema/transcript.go +++ b/internal/core/schema/transcript.go @@ -4,8 +4,10 @@ import ( "bytes" "encoding/json" "fmt" + "maps" "math" "slices" + "strings" "gitea.maximumdirect.net/eric/audita/v3/internal/core/jsonnumber" ) @@ -19,6 +21,38 @@ type SourceSegment struct { Categories []string `json:"categories,omitempty"` } +// UnmarshalJSON decodes only the final value of each exact key, then applies +// case variants in the same key order as the original object round trip. +func (s *SourceSegment) UnmarshalJSON(raw []byte) error { + var members map[string]json.RawMessage + if err := json.Unmarshal(raw, &members); err != nil { + return err + } + for _, key := range slices.Sorted(maps.Keys(members)) { + var field any + switch { + case strings.EqualFold(key, "id"): + field = &s.ID + case strings.EqualFold(key, "speaker"): + field = &s.Speaker + case strings.EqualFold(key, "start"): + field = &s.Start + case strings.EqualFold(key, "end"): + field = &s.End + case strings.EqualFold(key, "text"): + field = &s.Text + case strings.EqualFold(key, "categories"): + field = &s.Categories + default: + continue + } + if err := json.Unmarshal(members[key], field); err != nil { + return fmt.Errorf("field %q: %w", key, err) + } + } + return nil +} + type Segment struct { ID int `json:"id"` Speaker string `json:"speaker"` diff --git a/internal/core/schema/transcript_test.go b/internal/core/schema/transcript_test.go index a1bfefc..89b84d1 100644 --- a/internal/core/schema/transcript_test.go +++ b/internal/core/schema/transcript_test.go @@ -336,6 +336,36 @@ func TestSourceIDRejectsFractionAndOverflow(t *testing.T) { } } +func TestSourceTranscriptUsesEffectiveMemberValues(t *testing.T) { + for _, tc := range []struct { + name, speaker, text, wantText string + wantError bool + }{ + {"superseded type mismatch", `"speaker":17,"speaker":"A"`, `"text":"hello"`, "hello", false}, + {"effective type mismatch", `"speaker":"A","speaker":17`, `"text":"hello"`, "", true}, + {"case variant after exact key", `"speaker":"A"`, `"text":"hello","TEXT":"other"`, "hello", false}, + {"case variant before exact key", `"speaker":"A"`, `"TEXT":"other","text":"hello"`, "hello", false}, + } { + t.Run(tc.name, func(t *testing.T) { + raw := `[{` + tc.speaker + "," + tc.text + `,"start":0,"end":1}]` + transcript, err := ParseSourceTranscriptJSON([]byte(raw)) + if tc.wantError { + if err == nil { + t.Fatal("expected a type mismatch in the effective member") + } + return + } + if err != nil { + t.Fatal(err) + } + segment := transcript.Segments[0] + if segment.Speaker != "A" || segment.Text != tc.wantText { + t.Errorf("effective speaker = %q, text = %q", segment.Speaker, segment.Text) + } + }) + } +} + func TestTranscriptClonePreservesPresenceAndIndependence(t *testing.T) { original := &Transcript{Segments: []Segment{ {ID: 40, Text: "original", Categories: []string{"keep"}},