@xdarkicex/openclaw-memory-libravdb 1.3.5

package/sidecar/compact/gate.go

@@ -0,0 +1,273 @@
+package compact
+
+import (
+	"math"
+	"regexp"
+	"strings"
+
+	"github.com/xDarkicex/openclaw-memory-libravdb/sidecar/store"
+)
+
+const (
+	inputFrequencyThreshold = 0.80
+	inputFrequencyCap       = 5.0
+	memSaturationThreshold  = 0.85
+	memSaturationCap        = 3.0
+)
+
+// GatingConfig holds all weights and normalization constants.
+// All weights within each branch must sum to 1.0 by convention.
+type GatingConfig struct {
+	W1c float64
+	W2c float64
+	W3c float64
+
+	W1t float64
+	W2t float64
+	W3t float64
+
+	TechNorm  float64
+	Threshold float64
+}
+
+func DefaultGatingConfig() GatingConfig {
+	return GatingConfig{
+		W1c: 0.35, W2c: 0.40, W3c: 0.25,
+		W1t: 0.40, W2t: 0.35, W3t: 0.25,
+		TechNorm:  1.5,
+		Threshold: 0.35,
+	}
+}
+
+// GatingSignals holds all decomposed values for observability.
+// Every field is stored in record metadata.
+type GatingSignals struct {
+	G float64 `json:"g"`
+	T float64 `json:"t"`
+
+	H float64 `json:"h"`
+	R float64 `json:"r"`
+	D float64 `json:"d"`
+
+	InputFreq     float64 `json:"inputFreq"`
+	MemSaturation float64 `json:"memSaturation"`
+
+	P     float64 `json:"p"`
+	A     float64 `json:"a"`
+	Dtech float64 `json:"dtech"`
+
+	Gconv float64 `json:"gconv"`
+	Gtech float64 `json:"gtech"`
+}
+
+var (
+	datePattern          = regexp.MustCompile(`\b(?:\d{4}-\d{2}-\d{2}|\d{1,2}/\d{1,2}/\d{2,4})\b`)
+	quantityPattern      = regexp.MustCompile(`\b\d+(?:\.\d+)?\b`)
+	humanNamePattern     = regexp.MustCompile(`(?i)\b(?:mr|mrs|ms|dr|prof)\.?\s+[A-Z][a-z]+\b|\b(?:my (?:manager|teammate|friend|colleague))\s+[A-Z][a-z]+\b`)
+	preferencePattern    = regexp.MustCompile(`(?i)\b(?:i prefer|i like|i love|my favorite|i enjoy)\b`)
+	factAssertionPattern = regexp.MustCompile(`(?i)\b(?:i work at|my [a-z]+ is|i live in|i am|i have)\b`)
+
+	codeFencePattern      = regexp.MustCompile("(?s)```.+?```")
+	filePathPattern       = regexp.MustCompile(`(?:\./|\.\./|/)?[\w.-]+(?:/[\w.-]+)+(?:\.[A-Za-z0-9]+)?`)
+	functionDefPattern    = regexp.MustCompile(`(?m)\b(?:func|def|class)\b|\b[A-Za-z_][A-Za-z0-9_]*\s*\(`)
+	shellCommandPattern   = regexp.MustCompile(`(?m)(?:^\s*\$|\b(?:git|npm|pnpm|yarn|go|docker|make|kubectl)\b)`)
+	urlOrEndpointPattern  = regexp.MustCompile(`https?://\S+|/[A-Za-z0-9._~/-]+`)
+	stackTracePattern     = regexp.MustCompile(`(?i)\b(?:panic:|goroutine \d+|stack trace|traceback|exception:|at [^:\s]+:\d+)\b`)
+	hexOrHashPattern      = regexp.MustCompile(`\b(?:[a-f0-9]{7,40}|0x[a-fA-F0-9]+)\b`)
+	functionRefPattern    = regexp.MustCompile(`\b[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)?\s*\(`)
+	errorCodePattern      = regexp.MustCompile(`(?i)\b(?:ERR_[A-Z0-9_]+|E[A-Z0-9_]{2,}|HTTP\s+[45]\d{2}|[45]\d{2})\b`)
+	gitRefPattern         = regexp.MustCompile(`\b(?:[a-f0-9]{7,40}|HEAD|main|master|origin/[A-Za-z0-9._/-]+)\b`)
+	archDecisionPattern   = regexp.MustCompile(`(?i)\b(?:switched to|use .+ instead|migrated to|replaced with|decided to|standardize on)\b`)
+	resolutionPattern     = regexp.MustCompile(`(?i)\b(?:fixed|resolved|patched|corrected|unblocked)\b`)
+	milestonePattern      = regexp.MustCompile(`(?i)\b(?:deployed|merged|released|shipped|rolled out)\b`)
+	configChangePattern   = regexp.MustCompile(`(?i)\b(?:set [A-Za-z0-9_]+ to|configured|configuration changed|env(?:ironment)? var)\b`)
+	dataStructurePattern  = regexp.MustCompile(`(?i)\b(?:struct|interface|type|enum|map\[)\b`)
+	dependencyPattern     = regexp.MustCompile(`(?i)\b(?:import|require|go\.mod|package\.json|dependency|depends on)\b`)
+	testCasePattern       = regexp.MustCompile(`(?i)\b(?:func Test\w+|it\(|describe\(|test\()\b`)
+	docCommentPattern     = regexp.MustCompile(`(?m)(?:^\s*//|/\*\*|///)`)
+)
+
+// ComputeGating is a pure function.
+// turnHits: SearchText(turns:userId, text, 10)
+// memHits:  SearchText(user:userId, text, 5)
+func ComputeGating(turnHits, memHits []store.SearchResult, text string, cfg GatingConfig) GatingSignals {
+	techT := computeT(text, cfg.TechNorm)
+
+	h := computeH(memHits)
+	inputFreq := math.Min(float64(countAbove(turnHits, inputFrequencyThreshold))/inputFrequencyCap, 1.0)
+	memSaturation := math.Min(float64(countAbove(memHits, memSaturationThreshold))/memSaturationCap, 1.0)
+	r := inputFreq * (1.0 - memSaturation)
+	dnl := computeDNL(text)
+
+	p := computeP(text)
+	a := computeA(text)
+	dtech := computeDTech(text)
+
+	gConv := cfg.W1c*h + cfg.W2c*r + cfg.W3c*dnl
+	gTech := cfg.W1t*p + cfg.W2t*a + cfg.W3t*dtech
+	g := (1.0-techT)*gConv + techT*gTech
+
+	return GatingSignals{
+		G: g, T: techT,
+		H: h, R: r, D: dnl,
+		InputFreq:     inputFreq,
+		MemSaturation: memSaturation,
+		P:             p,
+		A:             a,
+		Dtech:         dtech,
+		Gconv:         gConv,
+		Gtech:         gTech,
+	}
+}
+
+func (s GatingSignals) Passes(cfg GatingConfig) bool {
+	return s.G >= cfg.Threshold
+}
+
+func countAbove(hits []store.SearchResult, threshold float64) int {
+	count := 0
+	for _, hit := range hits {
+		if hit.Score >= threshold {
+			count++
+		}
+	}
+	return count
+}
+
+func computeH(hits []store.SearchResult) float64 {
+	if len(hits) == 0 {
+		return 1.0
+	}
+	var sum float64
+	for _, hit := range hits {
+		sum += hit.Score
+	}
+	return 1.0 - (sum / float64(len(hits)))
+}
+
+func computeT(text string, norm float64) float64 {
+	text = strings.TrimSpace(text)
+	if text == "" {
+		return 0.0
+	}
+	if norm <= 0 {
+		norm = 1.5
+	}
+
+	score := 0.0
+	if codeFencePattern.MatchString(text) {
+		score += 0.5
+	}
+	if filePathPattern.MatchString(text) {
+		score += 0.4
+	}
+	if functionDefPattern.MatchString(text) {
+		score += 0.4
+	}
+	if shellCommandPattern.MatchString(text) {
+		score += 0.4
+	}
+	if urlOrEndpointPattern.MatchString(text) {
+		score += 0.3
+	}
+	if stackTracePattern.MatchString(text) {
+		score += 0.5
+	}
+	if hexOrHashPattern.MatchString(text) {
+		score += 0.3
+	}
+	return math.Min(score/norm, 1.0)
+}
+
+func computeDNL(text string) float64 {
+	text = strings.TrimSpace(text)
+	if text == "" {
+		return 0.0
+	}
+
+	score := 0.0
+	if datePattern.MatchString(text) {
+		score += 0.3
+	}
+	if quantityPattern.MatchString(text) {
+		score += 0.2
+	}
+	if humanNamePattern.MatchString(text) {
+		score += 0.3
+	}
+	if preferencePattern.MatchString(text) {
+		score += 0.4
+	}
+	if factAssertionPattern.MatchString(text) {
+		score += 0.3
+	}
+	return math.Min(score, 1.0)
+}
+
+func computeP(text string) float64 {
+	text = strings.TrimSpace(text)
+	if text == "" {
+		return 0.0
+	}
+
+	norm := math.Max(float64(EstimateTokens(text))/100.0, 1.0)
+	score := 0.0
+	score += float64(countMatches(filePathPattern, text)) * 0.4
+	score += float64(countMatches(functionRefPattern, text)) * 0.3
+	score += float64(countMatches(errorCodePattern, text)) * 0.5
+	score += float64(countMatches(gitRefPattern, text)) * 0.4
+	score += float64(countMatches(urlOrEndpointPattern, text)) * 0.3
+
+	return math.Min(score/norm, 1.0)
+}
+
+func computeA(text string) float64 {
+	text = strings.TrimSpace(text)
+	if text == "" {
+		return 0.0
+	}
+
+	score := 0.0
+	if archDecisionPattern.MatchString(text) {
+		score += 0.5
+	}
+	if resolutionPattern.MatchString(text) {
+		score += 0.4
+	}
+	if milestonePattern.MatchString(text) {
+		score += 0.3
+	}
+	if configChangePattern.MatchString(text) {
+		score += 0.4
+	}
+	return math.Min(score, 1.0)
+}
+
+func computeDTech(text string) float64 {
+	text = strings.TrimSpace(text)
+	if text == "" {
+		return 0.0
+	}
+
+	score := 0.0
+	if functionDefPattern.MatchString(text) {
+		score += 0.4
+	}
+	if dataStructurePattern.MatchString(text) {
+		score += 0.3
+	}
+	if dependencyPattern.MatchString(text) {
+		score += 0.3
+	}
+	if testCasePattern.MatchString(text) {
+		score += 0.2
+	}
+	if docCommentPattern.MatchString(text) {
+		score += 0.2
+	}
+	return math.Min(score, 1.0)
+}
+
+func countMatches(pattern *regexp.Regexp, text string) int {
+	return len(pattern.FindAllString(text, -1))
+}

package/sidecar/compact/gate_test.go

@@ -0,0 +1,85 @@
+package compact
+
+import (
+	"math"
+	"testing"
+
+	"github.com/xDarkicex/openclaw-memory-libravdb/sidecar/store"
+)
+
+func TestHEmptyMemory(t *testing.T) {
+	sig := ComputeGating(nil, nil, "any text", DefaultGatingConfig())
+	if sig.H != 1.0 {
+		t.Errorf("H = %.6f, want 1.0 for empty memory", sig.H)
+	}
+}
+
+func TestRSaturationVetoes(t *testing.T) {
+	turnHits := hitsWithScore(10, 0.95)
+	memHits := hitsWithScore(5, 0.95)
+	sig := ComputeGating(turnHits, memHits, "any text", DefaultGatingConfig())
+	if sig.R != 0.0 {
+		t.Errorf("R = %.6f, want 0.0 when memory saturated", sig.R)
+	}
+}
+
+func TestGConvexBound(t *testing.T) {
+	for _, text := range []string{"hello", "func main() {}", "```go\nfmt.Println()\n```"} {
+		sig := ComputeGating(nil, nil, text, DefaultGatingConfig())
+		if sig.G < 0.0 || sig.G > 1.0 {
+			t.Errorf("G = %.6f out of [0,1] for text %q", sig.G, text)
+		}
+		lo := math.Min(sig.Gconv, sig.Gtech)
+		hi := math.Max(sig.Gconv, sig.Gtech)
+		if sig.G < lo-1e-9 || sig.G > hi+1e-9 {
+			t.Errorf("G = %.6f not in [Gconv=%.6f, Gtech=%.6f]", sig.G, sig.Gconv, sig.Gtech)
+		}
+	}
+}
+
+func TestPurelyConversationalUsesConvFormula(t *testing.T) {
+	text := "I prefer dark mode and work best in the mornings"
+	sig := ComputeGating(nil, nil, text, DefaultGatingConfig())
+	if sig.T > 0.05 {
+		t.Skipf("text triggered T=%.2f, not purely conversational", sig.T)
+	}
+	if math.Abs(sig.G-sig.Gconv) > 1e-9 {
+		t.Errorf("G=%.9f ≠ Gconv=%.9f when T=0", sig.G, sig.Gconv)
+	}
+}
+
+func TestPurelyTechnicalUsesTechFormula(t *testing.T) {
+	text := "```go\nfunc (s *Store) InsertRecord(ctx context.Context) error {\n}\n```"
+	sig := ComputeGating(nil, nil, text, DefaultGatingConfig())
+	if sig.T < 0.95 {
+		t.Skipf("text triggered T=%.2f, not purely technical", sig.T)
+	}
+	if math.Abs(sig.G-sig.Gtech) > 1e-9 {
+		t.Errorf("G=%.9f ≠ Gtech=%.9f when T=1", sig.G, sig.Gtech)
+	}
+}
+
+func TestDNLDoesNotFireOnCode(t *testing.T) {
+	code := "func NewMatryoshkaVec(full []float32) (MatryoshkaVec, error) {"
+	sig := ComputeGating(nil, nil, code, DefaultGatingConfig())
+	if sig.D > 0.3 {
+		t.Errorf("D_nl = %.4f overfiring on code text", sig.D)
+	}
+}
+
+func TestEstimateTokensUsesStableByteHeuristic(t *testing.T) {
+	if got := EstimateTokens("abcd"); got != 1 {
+		t.Fatalf("EstimateTokens(\"abcd\") = %d, want 1", got)
+	}
+	if got := EstimateTokens("abcdefgh"); got != 2 {
+		t.Fatalf("EstimateTokens(\"abcdefgh\") = %d, want 2", got)
+	}
+}
+
+func hitsWithScore(n int, score float64) []store.SearchResult {
+	hits := make([]store.SearchResult, n)
+	for i := range hits {
+		hits[i] = store.SearchResult{ID: string(rune('a' + i)), Score: score}
+	}
+	return hits
+}

package/sidecar/compact/summarize.go

@@ -0,0 +1,345 @@
+package compact
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"log"
+	"math"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/xDarkicex/openclaw-memory-libravdb/sidecar/store"
+	"github.com/xDarkicex/openclaw-memory-libravdb/sidecar/summarize"
+)
+
+const (
+	DefaultTargetSize     = 20
+	DefaultMaxOutputTokens = 64
+	AbstractiveRoutingThreshold = 0.60
+)
+
+type Store interface {
+	ListByMeta(ctx context.Context, collection, key, value string) ([]store.SearchResult, error)
+	InsertText(ctx context.Context, collection, id, text string, meta map[string]any) error
+	DeleteBatch(ctx context.Context, collection string, ids []string) error
+}
+
+type Result struct {
+	DidCompact     bool    `json:"didCompact"`
+	ClustersFormed int     `json:"clustersFormed"`
+	TurnsRemoved   int     `json:"turnsRemoved"`
+	SummaryMethod  string  `json:"summaryMethod,omitempty"`
+	MeanConfidence float64 `json:"meanConfidence"`
+}
+
+type cluster struct {
+	turns []turnRecord
+}
+
+type turnRecord struct {
+	id       string
+	text     string
+	metadata map[string]any
+	ts       int64
+}
+
+func CompactSession(
+	ctx context.Context,
+	st Store,
+	extractive summarize.Summarizer,
+	abstractive summarize.Summarizer,
+	sessionID string,
+	force bool,
+	targetSize int,
+) (Result, error) {
+	if strings.TrimSpace(sessionID) == "" {
+		return Result{}, fmt.Errorf("session ID is required")
+	}
+	if st == nil {
+		return Result{}, fmt.Errorf("store is required")
+	}
+	if extractive == nil {
+		return Result{}, fmt.Errorf("extractive summarizer is required")
+	}
+	if !extractive.Ready() {
+		return Result{}, fmt.Errorf("extractive summarizer not ready: %s", extractive.Reason())
+	}
+
+	targetSize = normalizedTargetSize(targetSize)
+	collection := "session:" + sessionID
+	results, err := st.ListByMeta(ctx, collection, "sessionId", sessionID)
+	if err != nil {
+		return Result{}, err
+	}
+
+	turns := eligibleTurns(results)
+	if len(turns) < 2 {
+		return Result{DidCompact: false}, nil
+	}
+	if !force && len(turns) < targetSize {
+		return Result{DidCompact: false}, nil
+	}
+
+	clusters := partitionChronological(turns, targetSize)
+	if len(clusters) == 0 {
+		return Result{DidCompact: false}, nil
+	}
+
+	now := time.Now().UnixMilli()
+	out := Result{
+		DidCompact:     true,
+		ClustersFormed: len(clusters),
+	}
+	var totalConfidence float64
+
+	for idx, group := range clusters {
+		if len(group.turns) == 0 {
+			continue
+		}
+
+		summaryTurns := make([]summarize.Turn, 0, len(group.turns))
+		sourceIDs := make([]string, 0, len(group.turns))
+		for _, turn := range group.turns {
+			summaryTurns = append(summaryTurns, summarize.Turn{
+				ID:   turn.id,
+				Text: turn.text,
+			})
+			sourceIDs = append(sourceIDs, turn.id)
+		}
+
+		summarizer, meanGating := routeSummarizer(group.turns, extractive, abstractive)
+		log.Printf("compaction: cluster_id=%d mean_gating_score=%.3f summarizer_used=%s", idx, meanGating, summarizer.Mode())
+
+		summary, err := summarizer.Summarize(ctx, summaryTurns, summarize.SummaryOpts{
+			MinInputTurns:   1,
+			MaxOutputTokens: DefaultMaxOutputTokens,
+		})
+		if err != nil {
+			return Result{}, fmt.Errorf("cluster %d summarize failed: %w", idx, err)
+		}
+		if strings.TrimSpace(summary.Text) == "" {
+			return Result{}, fmt.Errorf("cluster %d summarize produced empty text", idx)
+		}
+
+		summary.SourceIDs = append([]string(nil), sourceIDs...)
+
+		metadata := summaryMetadata(sessionID, now, summary, group.turns)
+		summaryID := summaryRecordID(sessionID, summary.SourceIDs)
+		if err := st.InsertText(ctx, collection, summaryID, summary.Text, metadata); err != nil {
+			return Result{}, fmt.Errorf("summary insert failed, source turns preserved: %w", err)
+		}
+
+		if err := st.DeleteBatch(ctx, collection, summary.SourceIDs); err != nil {
+			log.Printf("compaction: summary %s inserted but source delete failed: %v", summaryID, err)
+		} else {
+			out.TurnsRemoved += len(summary.SourceIDs)
+		}
+
+		totalConfidence += summary.Confidence
+		out.SummaryMethod = mergeMethod(out.SummaryMethod, summary.Method)
+	}
+
+	if out.ClustersFormed > 0 {
+		out.MeanConfidence = clamp01(totalConfidence / float64(out.ClustersFormed))
+	}
+	return out, nil
+}
+
+func routeSummarizer(turns []turnRecord, extractive summarize.Summarizer, abstractive summarize.Summarizer) (summarize.Summarizer, float64) {
+	meanGating := meanGatingScore(turns)
+	if abstractive == nil || !abstractive.Ready() {
+		return extractive, meanGating
+	}
+	if meanGating >= AbstractiveRoutingThreshold {
+		return abstractive, meanGating
+	}
+	return extractive, meanGating
+}
+
+func meanGatingScore(turns []turnRecord) float64 {
+	if len(turns) == 0 {
+		return 0.0
+	}
+	var sum float64
+	for _, turn := range turns {
+		sum += metaFloat(turn.metadata, "gating_score")
+	}
+	return clamp01(sum / float64(len(turns)))
+}
+
+func normalizedTargetSize(targetSize int) int {
+	if targetSize <= 0 {
+		return DefaultTargetSize
+	}
+	return targetSize
+}
+
+func eligibleTurns(results []store.SearchResult) []turnRecord {
+	turns := make([]turnRecord, 0, len(results))
+	for _, result := range results {
+		typed, ok := result.Metadata["type"].(string)
+		if ok && typed == "summary" {
+			continue
+		}
+
+		turns = append(turns, turnRecord{
+			id:       result.ID,
+			text:     result.Text,
+			metadata: cloneMeta(result.Metadata),
+			ts:       metadataTimestamp(result.Metadata),
+		})
+	}
+
+	sort.Slice(turns, func(i, j int) bool {
+		if turns[i].ts == turns[j].ts {
+			return turns[i].id < turns[j].id
+		}
+		return turns[i].ts < turns[j].ts
+	})
+	return turns
+}
+
+func partitionChronological(turns []turnRecord, targetSize int) []cluster {
+	if len(turns) == 0 {
+		return nil
+	}
+	targetSize = normalizedTargetSize(targetSize)
+	clusterCount := int(math.Ceil(float64(len(turns)) / float64(targetSize)))
+	if clusterCount < 1 {
+		clusterCount = 1
+	}
+
+	clusters := make([]cluster, clusterCount)
+	for i, turn := range turns {
+		index := i * clusterCount / len(turns)
+		clusters[index].turns = append(clusters[index].turns, turn)
+	}
+
+	out := make([]cluster, 0, len(clusters))
+	for _, group := range clusters {
+		if len(group.turns) > 0 {
+			out = append(out, group)
+		}
+	}
+	return out
+}
+
+func summaryMetadata(sessionID string, compactedAt int64, summary summarize.Summary, turns []turnRecord) map[string]any {
+	meta := map[string]any{
+		"type":         "summary",
+		"ts":           compactedAt,
+		"sessionId":    sessionID,
+		"source_ids":   append([]string(nil), summary.SourceIDs...),
+		"method":       summary.Method,
+		"token_count":  summary.TokenCount,
+		"confidence":   clamp01(summary.Confidence),
+		"compacted_at": compactedAt,
+		"decay_rate":   clamp01(1.0 - summary.Confidence),
+	}
+
+	for _, turn := range turns {
+		if userID, ok := turn.metadata["userId"]; ok && userID != nil {
+			meta["userId"] = userID
+			break
+		}
+	}
+	return meta
+}
+
+func summaryRecordID(sessionID string, sourceIDs []string) string {
+	hash := sha256.Sum256([]byte(sessionID + ":" + strings.Join(sourceIDs, ",")))
+	return "summary:" + hex.EncodeToString(hash[:8])
+}
+
+func metadataTimestamp(meta map[string]any) int64 {
+	value, ok := meta["ts"]
+	if !ok {
+		return 0
+	}
+	switch typed := value.(type) {
+	case int:
+		return int64(typed)
+	case int64:
+		return typed
+	case int32:
+		return int64(typed)
+	case float64:
+		return int64(typed)
+	case float32:
+		return int64(typed)
+	case jsonNumber:
+		n, _ := typed.Int64()
+		return n
+	case string:
+		n, err := strconv.ParseInt(typed, 10, 64)
+		if err == nil {
+			return n
+		}
+	}
+	return 0
+}
+
+func metaFloat(meta map[string]any, key string) float64 {
+	value, ok := meta[key]
+	if !ok {
+		return 0.0
+	}
+	switch typed := value.(type) {
+	case float64:
+		return typed
+	case float32:
+		return float64(typed)
+	case int:
+		return float64(typed)
+	case int64:
+		return float64(typed)
+	case int32:
+		return float64(typed)
+	case string:
+		n, err := strconv.ParseFloat(strings.TrimSpace(typed), 64)
+		if err == nil {
+			return n
+		}
+	}
+	return 0.0
+}
+
+type jsonNumber interface {
+	Int64() (int64, error)
+}
+
+func cloneMeta(src map[string]any) map[string]any {
+	if src == nil {
+		return map[string]any{}
+	}
+	dst := make(map[string]any, len(src))
+	for k, v := range src {
+		dst[k] = v
+	}
+	return dst
+}
+
+func mergeMethod(current, next string) string {
+	switch {
+	case current == "":
+		return next
+	case current == next:
+		return current
+	default:
+		return "mixed"
+	}
+}
+
+func clamp01(v float64) float64 {
+	if v < 0 {
+		return 0
+	}
+	if v > 1 {
+		return 1
+	}
+	return v
+}