[FIX] - Prevent duplicates on clock sequence wrap;

Author: atlet99

generator.go

@@ -431,6 +431,21 @@ func (g *Gen) getClockSequence(useUnixTSMs bool, atTime time.Time) (uint64, uint
 	} else {
 		timeNow = g.getEpoch(atTime)
 	}
+	now := func() uint64 {
+		epoch := g.epochFunc()
+		if useUnixTSMs {
+			return uint64(epoch.UnixMilli())
+		}
+
+		return g.getEpoch(epoch)
+	}
+
+	// Calls can arrive with stale atTime values (captured before acquiring the
+	// lock). Clamp backwards timestamps to the latest emitted one to avoid
+	// reusing older timestamp + clock-sequence pairs after sequence wrap.
+	if timeNow < g.lastTime {
+		timeNow = g.lastTime
+	}
 	// Clock didn't change since last UUID generation.
 	// Should increase clock sequence.
 	if timeNow <= g.lastTime {
@@ -442,15 +457,7 @@ func (g *Gen) getClockSequence(useUnixTSMs bool, atTime time.Time) (uint64, uint
 		// If the sequence wrapped (back to zero) we MUST wait for the
 		// timestamp to advance to preserve uniqueness (see RFC-9562 §6.1).
 		if g.clockSequence == 0 {
-			for {
-				if useUnixTSMs {
-					timeNow = uint64(g.epochFunc().UnixMilli())
-				} else {
-					timeNow = g.getEpoch(g.epochFunc())
-				}
-				if timeNow > g.lastTime {
-					break
-				}
+			for ; timeNow <= g.lastTime; timeNow = now() {
 				// Sleep briefly to avoid busy-waiting and reduce CPU usage.
 				time.Sleep(time.Microsecond)
 			}

generator_test.go

@@ -54,6 +54,7 @@ func testNewV1(t *testing.T) {
 	t.Run("MissingNetworkFaultyRand", testNewV1MissingNetworkFaultyRand)
 	t.Run("MissingNetworkFaultyRandWithOptions", testNewV1MissingNetworkFaultyRandWithOptions)
 	t.Run("AtSpecificTime", testNewV1AtTime)
+	t.Run("AtSpecificTimeClockSequenceWrap", testNewV1AtTimeClockSequenceWrap)
 }
 
 func TestNewGenWithHWAF(t *testing.T) {
@@ -273,6 +274,35 @@ func testNewV1AtTime(t *testing.T) {
 	}
 }
 
+func testNewV1AtTimeClockSequenceWrap(t *testing.T) {
+	atTime := time.Unix(0, 1000000)
+
+	g := NewGenWithOptions(
+		WithHWAddrFunc(func() (net.HardwareAddr, error) {
+			return net.HardwareAddr{0, 1, 2, 3, 4, 5}, nil
+		}),
+		WithEpochFunc(func() time.Time {
+			return time.Unix(0, 2000000)
+		}),
+		WithRandomReader(bytes.NewReader([]byte{0x00, 0x00})),
+	)
+
+	const total = 0x3fff + 3
+	seen := make(map[UUID]int, total)
+
+	for i := 0; i < total; i++ {
+		u, err := g.NewV1AtTime(atTime)
+		if err != nil {
+			t.Fatalf("g.NewV1AtTime() err = %v, want <nil>", err)
+		}
+
+		if prev, ok := seen[u]; ok {
+			t.Fatalf("duplicate UUID at iteration %d (previous %d): %s", i, prev, u)
+		}
+		seen[u] = i
+	}
+}
+
 func testNewV1FaultyRandWithOptions(t *testing.T) {
 	g := NewGenWithOptions(WithRandomReader(&faultyReader{
 		readToFail: 0, // fail immediately