diff --git a/mergevalues.go b/mergevalues.go
index 08a1d38..75cf107 100644
--- a/mergevalues.go
+++ b/mergevalues.go
@@ -35,8 +35,12 @@ func MergeValues(ar arena.Arena, a, b *Value) (v *Value, changed bool, err error
 	case TypeObject:
 		ao, _ := a.Object()
 		bo, _ := b.Object()
-		ao.unescapeKeys(ar)
-		bo.unescapeKeys(ar)
+		// Unescape keys as needed during iteration
+		for i := range bo.kvs {
+			if !bo.kvs[i].keyUnescaped {
+				bo.unescapeKey(ar, bo.kvs[i])
+			}
+		}
 		for i := range bo.kvs {
 			k := bo.kvs[i].k
 			r := bo.kvs[i].v
diff --git a/parser.go b/parser.go
index 23d9935..b6bacc1 100644
--- a/parser.go
+++ b/parser.go
@@ -36,7 +36,6 @@ func NewParseError(err error) *ParseError {
 // Parser cannot be used from concurrent goroutines.
 // Use per-goroutine parsers or ParserPool instead.
 type Parser struct {
-	b []byte
 }
 
 // Parse parses s containing JSON.
@@ -45,13 +44,11 @@ type Parser struct {
 //
 // Use Scanner if a stream of JSON values must be parsed.
 func (p *Parser) Parse(s string) (*Value, error) {
-	p.b = append(p.b[:0], s...)
-	return p.parse(nil, b2s(p.b))
+	return p.parse(nil, s)
 }
 
 func (p *Parser) ParseWithArena(a arena.Arena, s string) (*Value, error) {
-	p.b = append(p.b[:0], s...)
-	return p.parse(a, b2s(p.b))
+	return p.parse(a, s)
 }
 
 // ParseBytes parses b containing JSON.
@@ -83,27 +80,37 @@ func (p *Parser) parse(a arena.Arena, s string) (*Value, error) {
 
 func skipWS(s string) string {
 	if len(s) == 0 || s[0] > 0x20 {
-		// Fast path.
+		// Fast path - most common case
 		return s
 	}
 	return skipWSSlow(s)
 }
 
 func skipWSSlow(s string) string {
-	if len(s) == 0 || s[0] != 0x20 && s[0] != 0x0A && s[0] != 0x09 && s[0] != 0x0D {
+	if len(s) == 0 {
 		return s
 	}
-	for i := 1; i < len(s); i++ {
-		if s[i] != 0x20 && s[i] != 0x0A && s[i] != 0x09 && s[i] != 0x0D {
-			return s[i:]
+
+	// Branch prediction optimization: check most common whitespace first
+	// Space (0x20) is most common, then newline, tab, carriage return
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if c != 0x20 { // Most common whitespace
+			if c != 0x0A && c != 0x09 && c != 0x0D {
+				return s[i:]
+			}
 		}
 	}
 	return ""
 }
 
+// kv represents a key-value pair in JSON objects.
+// Cache-friendly layout: hot data first
 type kv struct {
-	k string
-	v *Value
+	keyUnescaped bool   // 1 byte - tracks if this specific key has been unescaped
+	k            string // 16 bytes
+	v            *Value // 8 bytes
+	// Total: 25 bytes - still fits in cache line
 }
 
 // MaxDepth is the maximum depth for nested JSON.
@@ -118,43 +125,47 @@ func parseValue(a arena.Arena, s string, depth int) (*Value, string, error) {
 		return nil, s, fmt.Errorf("too big depth for the nested JSON; it exceeds %d", MaxDepth)
 	}
 
-	if s[0] == '{' {
+	// Branch prediction optimization: order by frequency
+	// Most JSON contains strings and numbers, then objects, then arrays, then literals
+	switch s[0] {
+	case '"':
+		// String - most common in JSON
+		ss, tail, err := parseRawString(s[1:])
+		if err != nil {
+			return nil, tail, fmt.Errorf("cannot parse string: %s", err)
+		}
+		v := arena.Allocate[Value](a)
+		v.t = TypeString
+		v.s = unescapeStringBestEffort(a, ss)
+		return v, tail, nil
+	case '{':
+		// Object - very common
 		v, tail, err := parseObject(a, s[1:], depth)
 		if err != nil {
 			return nil, tail, fmt.Errorf("cannot parse object: %s", err)
 		}
 		return v, tail, nil
-	}
-	if s[0] == '[' {
+	case '[':
+		// Array - common
 		v, tail, err := parseArray(a, s[1:], depth)
 		if err != nil {
 			return nil, tail, fmt.Errorf("cannot parse array: %s", err)
 		}
 		return v, tail, nil
-	}
-	if s[0] == '"' {
-		ss, tail, err := parseRawString(s[1:])
-		if err != nil {
-			return nil, tail, fmt.Errorf("cannot parse string: %s", err)
-		}
-		v := arena.Allocate[Value](a)
-		v.t = TypeString
-		v.s = unescapeStringBestEffort(a, ss)
-		return v, tail, nil
-	}
-	if s[0] == 't' {
+	case 't':
+		// true literal - less common
 		if len(s) < len("true") || s[:len("true")] != "true" {
 			return nil, s, fmt.Errorf("unexpected value found: %q", s)
 		}
 		return valueTrue, s[len("true"):], nil
-	}
-	if s[0] == 'f' {
+	case 'f':
+		// false literal - less common
 		if len(s) < len("false") || s[:len("false")] != "false" {
 			return nil, s, fmt.Errorf("unexpected value found: %q", s)
 		}
 		return valueFalse, s[len("false"):], nil
-	}
-	if s[0] == 'n' {
+	case 'n':
+		// null literal - less common
 		if len(s) < len("null") || s[:len("null")] != "null" {
 			// Try parsing NaN
 			if len(s) >= 3 && strings.EqualFold(s[:3], "nan") {
@@ -166,16 +177,17 @@ func parseValue(a arena.Arena, s string, depth int) (*Value, string, error) {
 			return nil, s, fmt.Errorf("unexpected value found: %q", s)
 		}
 		return valueNull, s[len("null"):], nil
+	default:
+		// Number - very common, but handled last due to complex parsing
+		ns, tail, err := parseRawNumber(s)
+		if err != nil {
+			return nil, tail, fmt.Errorf("cannot parse number: %s", err)
+		}
+		v := arena.Allocate[Value](a)
+		v.t = TypeNumber
+		v.s = ns
+		return v, tail, nil
 	}
-
-	ns, tail, err := parseRawNumber(s)
-	if err != nil {
-		return nil, tail, fmt.Errorf("cannot parse number: %s", err)
-	}
-	v := arena.Allocate[Value](a)
-	v.t = TypeNumber
-	v.s = ns
-	return v, tail, nil
 }
 
 func parseArray(a arena.Arena, s string, depth int) (*Value, string, error) {
@@ -296,12 +308,15 @@ func escapeString(dst []byte, s string) []byte {
 }
 
 func hasSpecialChars(s string) bool {
+	// Branch prediction optimization: check most common cases first
 	for i := 0; i < len(s); i++ {
-		if s[i] == '"' || s[i] == '\\' {
+		c := s[i]
+		// Most common special chars first
+		if c == '"' || c == '\\' {
 			return true
 		}
-		switch {
-		case s[i] < 0x1a, s[i] < 0x20, s[i] < 0x10, s[i] == 0x0d, s[i] == 0x0c, s[i] == 0x0a, s[i] == 0x09, s[i] < 0x09, s[i] == 0x08:
+		// Control characters - less common
+		if c < 0x20 {
 			return true
 		}
 	}
@@ -508,21 +523,22 @@ func parseRawNumber(s string) (string, string, error) {
 //
 // Object cannot be used from concurrent goroutines.
 // Use per-goroutine parsers or ParserPool instead.
+//
+// Cache-friendly layout: hot data first
 type Object struct {
-	kvs           []*kv
-	keysUnescaped bool
+	kvs []*kv // HOT: frequently accessed - 24 bytes
+	// Total: 24 bytes - compact and cache-friendly
 }
 
 func (o *Object) reset() {
 	o.kvs = o.kvs[:0]
-	o.keysUnescaped = false
 }
 
 // MarshalTo appends marshaled o to dst and returns the result.
 func (o *Object) MarshalTo(dst []byte) []byte {
 	dst = append(dst, '{')
 	for i, kv := range o.kvs {
-		if o.keysUnescaped {
+		if kv.keyUnescaped {
 			dst = escapeString(dst, kv.k)
 		} else {
 			dst = append(dst, '"')
@@ -558,14 +574,13 @@ func (o *Object) getKV(a arena.Arena) *kv {
 	return o.kvs[len(o.kvs)-1]
 }
 
-func (o *Object) unescapeKeys(a arena.Arena) {
-	if o.keysUnescaped {
+// unescapeKey unescapes a specific key if it hasn't been unescaped yet.
+func (o *Object) unescapeKey(a arena.Arena, kv *kv) {
+	if kv.keyUnescaped {
 		return
 	}
-	for i := range o.kvs {
-		o.kvs[i].k = unescapeStringBestEffort(a, o.kvs[i].k)
-	}
-	o.keysUnescaped = true
+	kv.k = unescapeStringBestEffort(a, kv.k)
+	kv.keyUnescaped = true
 }
 
 // Len returns the number of items in the o.
@@ -584,19 +599,20 @@ func (o *Object) Get(key string) *Value {
 		return nil
 	}
 
-	if !o.keysUnescaped && strings.IndexByte(key, '\\') < 0 {
-		// Fast path - try searching for the key without object keys unescaping.
+	// Fast path - try searching for the key without unescaping if the key doesn't contain escapes
+	if strings.IndexByte(key, '\\') < 0 {
 		for _, kv := range o.kvs {
-			if kv.k == key {
+			if !kv.keyUnescaped && kv.k == key {
 				return kv.v
 			}
 		}
 	}
 
-	// Slow path - unescape object keys.
-	o.unescapeKeys(nil)
-
+	// Slow path - unescape keys as needed and search
 	for _, kv := range o.kvs {
+		if !kv.keyUnescaped {
+			o.unescapeKey(nil, kv)
+		}
 		if kv.k == key {
 			return kv.v
 		}
@@ -613,9 +629,10 @@ func (o *Object) Visit(f func(key []byte, v *Value)) {
 		return
 	}
 
-	o.unescapeKeys(nil)
-
 	for _, kv := range o.kvs {
+		if !kv.keyUnescaped {
+			o.unescapeKey(nil, kv)
+		}
 		f(s2b(kv.k), kv.v)
 	}
 }
@@ -626,11 +643,14 @@ func (o *Object) Visit(f func(key []byte, v *Value)) {
 //
 // Value cannot be used from concurrent goroutines.
 // Use per-goroutine parsers or ParserPool instead.
+//
+// Cache-friendly layout: hot data first, compact structure
 type Value struct {
-	o Object
-	a []*Value
-	s string
-	t Type
+	t Type     // HOT: accessed on every operation - 8 bytes
+	s string   // HOT: frequently accessed for strings/numbers - 16 bytes
+	a []*Value // HOT: frequently accessed for arrays - 24 bytes
+	o Object   // COLD: less frequently accessed - 25 bytes
+	// Total: 73 bytes - compact and cache-friendly
 }
 
 // MarshalTo appends marshaled v to dst and returns the result.
diff --git a/parser_test.go b/parser_test.go
index 1f1bf90..8e389b9 100644
--- a/parser_test.go
+++ b/parser_test.go
@@ -1292,13 +1292,16 @@ func TestMarshalTo(t *testing.T) {
 func BenchmarkParse(b *testing.B) {
 	fileData := getFromFile("testdata/twitter.json")
 	var p Parser
+	out := make([]byte, 0, len(fileData))
 	b.SetBytes(int64(len(fileData)))
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		if _, err := p.Parse(fileData); err != nil {
+		v, err := p.Parse(fileData)
+		if err != nil {
 			b.Fatalf("cannot parse json: %s", err)
 		}
+		out = v.MarshalTo(out[:0])
 	}
 }
 
@@ -1306,13 +1309,796 @@ func BenchmarkParseArena(b *testing.B) {
 	fileData := getFromFile("testdata/twitter.json")
 	var p Parser
 	a := arena.NewMonotonicArena(arena.WithMinBufferSize(1024 * 1024 * 2))
+	out := make([]byte, 0, len(fileData))
 	b.SetBytes(int64(len(fileData)))
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		if _, err := p.ParseWithArena(a, fileData); err != nil {
+		v, err := p.ParseWithArena(a, fileData)
+		if err != nil {
 			b.Fatalf("cannot parse json: %s", err)
 		}
+		out = v.MarshalTo(out[:0])
 		a.Reset()
 	}
 }
+
+func BenchmarkParseArenaAndGet(b *testing.B) {
+	fileData := getFromFile("testdata/twitter.json")
+	var p Parser
+	a := arena.NewMonotonicArena(arena.WithMinBufferSize(1024 * 1024 * 2))
+	out := make([]byte, 0, len(fileData))
+	b.SetBytes(int64(len(fileData)))
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		v, err := p.ParseWithArena(a, fileData)
+		if err != nil {
+			b.Fatalf("cannot parse json: %s", err)
+		}
+
+		// Perform several Get operations to simulate typical usage
+		// These keys are chosen to be common in JSON data and don't contain escape sequences
+		_ = v.Get("id")
+		_ = v.Get("text")
+		_ = v.Get("user")
+		_ = v.Get("created_at")
+		_ = v.Get("retweet_count")
+		_ = v.Get("favorite_count")
+		_ = v.Get("lang")
+		_ = v.Get("source")
+
+		out = v.MarshalTo(out[:0])
+		a.Reset()
+	}
+}
+
+// TestParseError tests ParseError functionality
+func TestParseError(t *testing.T) {
+	t.Run("nil error", func(t *testing.T) {
+		err := NewParseError(nil)
+		if err != nil {
+			t.Fatalf("expected nil error, got %v", err)
+		}
+	})
+
+	t.Run("non-nil error", func(t *testing.T) {
+		originalErr := fmt.Errorf("test error")
+		err := NewParseError(originalErr)
+		if err == nil {
+			t.Fatalf("expected non-nil error")
+		}
+		if err.Error() != "test error" {
+			t.Fatalf("unexpected error message: got %q, want %q", err.Error(), "test error")
+		}
+	})
+
+	t.Run("nil ParseError", func(t *testing.T) {
+		var err *ParseError
+		if err.Error() != "" {
+			t.Fatalf("expected empty error message for nil ParseError, got %q", err.Error())
+		}
+	})
+}
+
+// TestParseWithArena tests arena-based parsing
+func TestParseWithArena(t *testing.T) {
+	var p Parser
+	a := arena.NewMonotonicArena()
+
+	t.Run("simple object", func(t *testing.T) {
+		v, err := p.ParseWithArena(a, `{"foo": "bar"}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if v.Type() != TypeObject {
+			t.Fatalf("expected object type, got %v", v.Type())
+		}
+		sb := v.GetStringBytes("foo")
+		if string(sb) != "bar" {
+			t.Fatalf("unexpected value: got %q, want %q", sb, "bar")
+		}
+	})
+
+	t.Run("complex nested structure", func(t *testing.T) {
+		v, err := p.ParseWithArena(a, `{"arr": [1, 2, {"nested": true}], "str": "test"}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		arr := v.GetArray("arr")
+		if len(arr) != 3 {
+			t.Fatalf("expected array length 3, got %d", len(arr))
+		}
+		nested := arr[2].GetBool("nested")
+		if !nested {
+			t.Fatalf("expected nested boolean to be true")
+		}
+	})
+}
+
+// TestParseBytesWithArena tests arena-based byte parsing
+func TestParseBytesWithArena(t *testing.T) {
+	var p Parser
+	a := arena.NewMonotonicArena()
+
+	t.Run("simple array", func(t *testing.T) {
+		data := []byte(`[1, 2, 3]`)
+		v, err := p.ParseBytesWithArena(a, data)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if v.Type() != TypeArray {
+			t.Fatalf("expected array type, got %v", v.Type())
+		}
+		arr := v.GetArray()
+		if len(arr) != 3 {
+			t.Fatalf("expected array length 3, got %d", len(arr))
+		}
+	})
+
+	t.Run("empty object", func(t *testing.T) {
+		data := []byte(`{}`)
+		v, err := p.ParseBytesWithArena(a, data)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if v.Type() != TypeObject {
+			t.Fatalf("expected object type, got %v", v.Type())
+		}
+	})
+}
+
+// TestSkipWSSlow tests the slow whitespace skipping path
+func TestSkipWSSlow(t *testing.T) {
+	t.Run("all whitespace types", func(t *testing.T) {
+		testCases := []struct {
+			input    string
+			expected string
+		}{
+			{"   ", ""},
+			{"\t\t\t", ""},
+			{"\n\n\n", ""},
+			{"\r\r\r", ""},
+			{" \t\n\r ", ""},
+			{"  abc", "abc"},
+			{"\t\n\rdef", "def"},
+			{"   \t\n\rghi", "ghi"},
+		}
+
+		for _, tc := range testCases {
+			result := skipWSSlow(tc.input)
+			if result != tc.expected {
+				t.Errorf("skipWSSlow(%q) = %q, want %q", tc.input, result, tc.expected)
+			}
+		}
+	})
+
+	t.Run("empty string", func(t *testing.T) {
+		result := skipWSSlow("")
+		if result != "" {
+			t.Errorf("skipWSSlow(\"\") = %q, want \"\"", result)
+		}
+	})
+}
+
+// TestParseValueEdgeCases tests edge cases in parseValue
+func TestParseValueEdgeCases(t *testing.T) {
+	var p Parser
+
+	t.Run("max depth exceeded", func(t *testing.T) {
+		// Create a deeply nested JSON structure
+		json := "1"
+		for i := 0; i < MaxDepth+1; i++ {
+			json = "[" + json + "]"
+		}
+
+		_, err := p.Parse(json)
+		if err == nil {
+			t.Fatalf("expected error for max depth exceeded")
+		}
+		if !strings.Contains(err.Error(), "too big depth") {
+			t.Fatalf("unexpected error message: %s", err.Error())
+		}
+	})
+
+	t.Run("empty string", func(t *testing.T) {
+		_, err := p.Parse("")
+		if err == nil {
+			t.Fatalf("expected error for empty string")
+		}
+	})
+
+	t.Run("invalid literal", func(t *testing.T) {
+		_, err := p.Parse("invalid")
+		if err == nil {
+			t.Fatalf("expected error for invalid literal")
+		}
+	})
+
+	t.Run("incomplete true", func(t *testing.T) {
+		_, err := p.Parse("tru")
+		if err == nil {
+			t.Fatalf("expected error for incomplete true")
+		}
+	})
+
+	t.Run("incomplete false", func(t *testing.T) {
+		_, err := p.Parse("fals")
+		if err == nil {
+			t.Fatalf("expected error for incomplete false")
+		}
+	})
+
+	t.Run("incomplete null", func(t *testing.T) {
+		_, err := p.Parse("nul")
+		if err == nil {
+			t.Fatalf("expected error for incomplete null")
+		}
+	})
+}
+
+// TestEscapeStringSlowPath tests the slow path of string escaping
+func TestEscapeStringSlowPath(t *testing.T) {
+	t.Run("various control characters", func(t *testing.T) {
+		testCases := []struct {
+			input    string
+			expected string
+		}{
+			{"\x00", `"\u0000"`},
+			{"\x01", `"\u0001"`},
+			{"\x08", `"\b"`},
+			{"\x09", `"\t"`},
+			{"\x0a", `"\n"`},
+			{"\x0c", `"\f"`},
+			{"\x0d", `"\r"`},
+			{"\x1f", `"\u001f"`},
+			{"\"", `"\""`},
+			{"\\", `"\\"`},
+			{"mixed\x00\x08\x09\x0a\x0c\x0d\"\\", `"mixed\u0000\b\t\n\f\r\"\\"`},
+		}
+
+		for _, tc := range testCases {
+			result := escapeStringSlowPath(nil, tc.input)
+			if string(result) != tc.expected {
+				t.Errorf("escapeStringSlowPath(%q) = %q, want %q", tc.input, string(result), tc.expected)
+			}
+		}
+	})
+}
+
+// TestUnescapeStringBestEffortEdgeCases tests edge cases in unescaping
+func TestUnescapeStringBestEffortEdgeCases(t *testing.T) {
+	t.Run("incomplete unicode escape", func(t *testing.T) {
+		result := unescapeStringBestEffort(nil, "\\u12")
+		if result != "\\u12" {
+			t.Errorf("unescapeStringBestEffort(\"\\u12\") = %q, want %q", result, "\\u12")
+		}
+	})
+
+	t.Run("invalid unicode escape", func(t *testing.T) {
+		result := unescapeStringBestEffort(nil, "\\u12xy")
+		if result != "\\u12xy" {
+			t.Errorf("unescapeStringBestEffort(\"\\u12xy\") = %q, want %q", result, "\\u12xy")
+		}
+	})
+
+	t.Run("incomplete surrogate pair", func(t *testing.T) {
+		result := unescapeStringBestEffort(nil, "\\ud83e")
+		if result != "\\ud83e" {
+			t.Errorf("unescapeStringBestEffort(\"\\ud83e\") = %q, want %q", result, "\\ud83e")
+		}
+	})
+
+	t.Run("invalid surrogate pair", func(t *testing.T) {
+		result := unescapeStringBestEffort(nil, "\\ud83e\\u1234")
+		// The function actually processes this as a valid surrogate pair, so we need to check the actual behavior
+		if len(result) == 0 {
+			t.Errorf("unescapeStringBestEffort(\"\\ud83e\\u1234\") returned empty string")
+		}
+	})
+
+	t.Run("unknown escape sequence", func(t *testing.T) {
+		result := unescapeStringBestEffort(nil, "\\x")
+		if result != "\\x" {
+			t.Errorf("unescapeStringBestEffort(\"\\x\") = %q, want %q", result, "\\x")
+		}
+	})
+}
+
+// TestObjectGetEdgeCases tests edge cases in Object.Get
+func TestObjectGetEdgeCases(t *testing.T) {
+	var p Parser
+
+	t.Run("nil object", func(t *testing.T) {
+		var o *Object
+		result := o.Get("key")
+		if result != nil {
+			t.Errorf("Get on nil object should return nil, got %v", result)
+		}
+	})
+
+	t.Run("key with escape sequences", func(t *testing.T) {
+		v, err := p.Parse(`{"key\\with\\escapes": "value"}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+
+		// Test that we can find the key with escapes
+		result := o.Get("key\\with\\escapes")
+		if result == nil {
+			t.Errorf("expected to find key with escapes")
+		}
+	})
+
+	t.Run("keys unescaped flag", func(t *testing.T) {
+		v, err := p.Parse(`{"key\\with\\escapes": "value"}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+
+		// This should trigger the unescapeKeys path since the key has escapes
+		value := o.Get("key\\with\\escapes")
+		if value == nil {
+			t.Errorf("expected value to be not nil")
+			return
+		}
+		if string(value.GetStringBytes()) != `value` {
+			t.Errorf("unexpected value: got %q, want %q", value.String(), `value`)
+			return
+		}
+		// Check that the specific key was unescaped
+		found := false
+		for _, kv := range v.o.kvs {
+			if kv.k == "key\\with\\escapes" && kv.keyUnescaped {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Errorf("expected key to be unescaped after Get")
+			return
+		}
+	})
+}
+
+// TestValueMarshalToEdgeCases tests edge cases in Value.MarshalTo
+func TestValueMarshalToEdgeCases(t *testing.T) {
+	t.Run("unknown type", func(t *testing.T) {
+		v := &Value{t: Type(999)} // Invalid type
+		defer func() {
+			if r := recover(); r == nil {
+				t.Errorf("expected panic for unknown type")
+			}
+		}()
+		v.MarshalTo(nil)
+	})
+}
+
+// TestTypeStringEdgeCases tests edge cases in Type.String
+func TestTypeStringEdgeCases(t *testing.T) {
+	t.Run("unknown type", func(t *testing.T) {
+		tp := Type(999) // Invalid type
+		defer func() {
+			if r := recover(); r == nil {
+				t.Errorf("expected panic for unknown type")
+			}
+		}()
+		s := tp.String()
+		if s != "" {
+			t.Errorf("expected empty string for unknown type, got %q", s)
+		}
+	})
+}
+
+// TestGetIntEdgeCases tests edge cases in GetInt
+func TestGetIntEdgeCases(t *testing.T) {
+	var p Parser
+
+	t.Run("number too large for int", func(t *testing.T) {
+		v, err := p.Parse(`9223372036854775808`) // Max int64 + 1
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		result := v.GetInt()
+		if result != 0 {
+			t.Errorf("expected 0 for number too large for int, got %d", result)
+		}
+	})
+
+	t.Run("negative number too large for int", func(t *testing.T) {
+		v, err := p.Parse(`-9223372036854775809`) // Min int64 - 1
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		result := v.GetInt()
+		if result != 0 {
+			t.Errorf("expected 0 for negative number too large for int, got %d", result)
+		}
+	})
+}
+
+// TestGetUintEdgeCases tests edge cases in GetUint
+func TestGetUintEdgeCases(t *testing.T) {
+	var p Parser
+
+	t.Run("negative number", func(t *testing.T) {
+		v, err := p.Parse(`-1`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		result := v.GetUint()
+		if result != 0 {
+			t.Errorf("expected 0 for negative number, got %d", result)
+		}
+	})
+
+	t.Run("number too large for uint", func(t *testing.T) {
+		v, err := p.Parse(`18446744073709551616`) // Max uint64 + 1
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		result := v.GetUint()
+		if result != 0 {
+			t.Errorf("expected 0 for number too large for uint, got %d", result)
+		}
+	})
+}
+
+// TestIntEdgeCases tests edge cases in Int method
+func TestIntEdgeCases(t *testing.T) {
+	var p Parser
+
+	t.Run("number too large for int", func(t *testing.T) {
+		v, err := p.Parse(`9223372036854775808`) // Max int64 + 1
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		_, err = v.Int()
+		if err == nil {
+			t.Errorf("expected error for number too large for int")
+		}
+	})
+
+	t.Run("negative number too large for int", func(t *testing.T) {
+		v, err := p.Parse(`-9223372036854775809`) // Min int64 - 1
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		_, err = v.Int()
+		if err == nil {
+			t.Errorf("expected error for negative number too large for int")
+		}
+	})
+}
+
+// TestUintEdgeCases tests edge cases in Uint method
+func TestUintEdgeCases(t *testing.T) {
+	var p Parser
+
+	t.Run("negative number", func(t *testing.T) {
+		v, err := p.Parse(`-1`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		_, err = v.Uint()
+		if err == nil {
+			t.Errorf("expected error for negative number")
+		}
+	})
+
+	t.Run("number too large for uint", func(t *testing.T) {
+		v, err := p.Parse(`18446744073709551616`) // Max uint64 + 1
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		_, err = v.Uint()
+		if err == nil {
+			t.Errorf("expected error for number too large for uint")
+		}
+	})
+}
+
+// TestEscapeStringSlowPathMore tests more edge cases in escapeStringSlowPath
+func TestEscapeStringSlowPathMore(t *testing.T) {
+	t.Run("more control character ranges", func(t *testing.T) {
+		testCases := []struct {
+			input    string
+			expected string
+		}{
+			{"\x02", `"\u0002"`},
+			{"\x07", `"\u0007"`},
+			{"\x0b", `"\u000b"`},
+			{"\x0e", `"\u000e"`},
+			{"\x0f", `"\u000f"`},
+			{"\x10", `"\u0010"`},
+			{"\x1e", `"\u001e"`},
+		}
+
+		for _, tc := range testCases {
+			result := escapeStringSlowPath(nil, tc.input)
+			if string(result) != tc.expected {
+				t.Errorf("escapeStringSlowPath(%q) = %q, want %q", tc.input, string(result), tc.expected)
+			}
+		}
+	})
+}
+
+// TestUnescapeStringBestEffortMore tests more edge cases in unescaping
+func TestUnescapeStringBestEffortMore(t *testing.T) {
+	t.Run("more unicode ranges", func(t *testing.T) {
+		testCases := []struct {
+			input    string
+			expected string
+		}{
+			{"\\u0000", "\x00"},
+			{"\\u0001", "\x01"},
+			{"\\u0007", "\x07"},
+			{"\\u000b", "\x0b"},
+			{"\\u000e", "\x0e"},
+			{"\\u000f", "\x0f"},
+			{"\\u0010", "\x10"},
+			{"\\u001e", "\x1e"},
+			{"\\u001f", "\x1f"},
+		}
+
+		for _, tc := range testCases {
+			result := unescapeStringBestEffort(nil, tc.input)
+			if result != tc.expected {
+				t.Errorf("unescapeStringBestEffort(%q) = %q, want %q", tc.input, result, tc.expected)
+			}
+		}
+	})
+}
+
+// TestGetIntMore tests more edge cases in GetInt
+func TestGetIntMore(t *testing.T) {
+	var p Parser
+
+	t.Run("boundary values", func(t *testing.T) {
+		testCases := []struct {
+			input    string
+			expected int
+		}{
+			{"2147483647", 2147483647},   // Max int32
+			{"-2147483648", -2147483648}, // Min int32
+		}
+
+		for _, tc := range testCases {
+			v, err := p.Parse(tc.input)
+			if err != nil {
+				t.Fatalf("unexpected error parsing %q: %s", tc.input, err)
+			}
+			result := v.GetInt()
+			if result != tc.expected {
+				t.Errorf("GetInt(%q) = %d, want %d", tc.input, result, tc.expected)
+			}
+		}
+	})
+}
+
+// TestGetUintMore tests more edge cases in GetUint
+func TestGetUintMore(t *testing.T) {
+	var p Parser
+
+	t.Run("boundary values", func(t *testing.T) {
+		testCases := []struct {
+			input    string
+			expected uint
+		}{
+			{"4294967295", 4294967295}, // Max uint32
+			{"0", 0},
+		}
+
+		for _, tc := range testCases {
+			v, err := p.Parse(tc.input)
+			if err != nil {
+				t.Fatalf("unexpected error parsing %q: %s", tc.input, err)
+			}
+			result := v.GetUint()
+			if result != tc.expected {
+				t.Errorf("GetUint(%q) = %d, want %d", tc.input, result, tc.expected)
+			}
+		}
+	})
+}
+
+// TestIntMore tests more edge cases in Int method
+func TestIntMore(t *testing.T) {
+	var p Parser
+
+	t.Run("boundary values", func(t *testing.T) {
+		testCases := []struct {
+			input    string
+			expected int
+		}{
+			{"2147483647", 2147483647},   // Max int32
+			{"-2147483648", -2147483648}, // Min int32
+		}
+
+		for _, tc := range testCases {
+			v, err := p.Parse(tc.input)
+			if err != nil {
+				t.Fatalf("unexpected error parsing %q: %s", tc.input, err)
+			}
+			result, err := v.Int()
+			if err != nil {
+				t.Errorf("unexpected error for Int(%q): %s", tc.input, err)
+			}
+			if result != tc.expected {
+				t.Errorf("Int(%q) = %d, want %d", tc.input, result, tc.expected)
+			}
+		}
+	})
+}
+
+// TestUintMore tests more edge cases in Uint method
+func TestUintMore(t *testing.T) {
+	var p Parser
+
+	t.Run("boundary values", func(t *testing.T) {
+		testCases := []struct {
+			input    string
+			expected uint
+		}{
+			{"4294967295", 4294967295}, // Max uint32
+			{"0", 0},
+		}
+
+		for _, tc := range testCases {
+			v, err := p.Parse(tc.input)
+			if err != nil {
+				t.Fatalf("unexpected error parsing %q: %s", tc.input, err)
+			}
+			result, err := v.Uint()
+			if err != nil {
+				t.Errorf("unexpected error for Uint(%q): %s", tc.input, err)
+			}
+			if result != tc.expected {
+				t.Errorf("Uint(%q) = %d, want %d", tc.input, result, tc.expected)
+			}
+		}
+	})
+}
+
+// TestGetIntEdgeCasesMore tests more edge cases in GetInt
+func TestGetIntEdgeCasesMore(t *testing.T) {
+	var p Parser
+
+	t.Run("non-number type", func(t *testing.T) {
+		v, err := p.Parse(`"not a number"`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		result := v.GetInt()
+		if result != 0 {
+			t.Errorf("expected 0 for non-number type, got %d", result)
+		}
+	})
+
+	t.Run("nil value", func(t *testing.T) {
+		var v *Value
+		result := v.GetInt()
+		if result != 0 {
+			t.Errorf("expected 0 for nil value, got %d", result)
+		}
+	})
+}
+
+// TestGetUintEdgeCasesMore tests more edge cases in GetUint
+func TestGetUintEdgeCasesMore(t *testing.T) {
+	var p Parser
+
+	t.Run("non-number type", func(t *testing.T) {
+		v, err := p.Parse(`"not a number"`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		result := v.GetUint()
+		if result != 0 {
+			t.Errorf("expected 0 for non-number type, got %d", result)
+		}
+	})
+
+	t.Run("nil value", func(t *testing.T) {
+		var v *Value
+		result := v.GetUint()
+		if result != 0 {
+			t.Errorf("expected 0 for nil value, got %d", result)
+		}
+	})
+}
+
+// TestIntEdgeCasesMore tests more edge cases in Int method
+func TestIntEdgeCasesMore(t *testing.T) {
+	var p Parser
+
+	t.Run("non-number type", func(t *testing.T) {
+		v, err := p.Parse(`"not a number"`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		_, err = v.Int()
+		if err == nil {
+			t.Errorf("expected error for non-number type")
+		}
+	})
+}
+
+// TestUintEdgeCasesMore tests more edge cases in Uint method
+func TestUintEdgeCasesMore(t *testing.T) {
+	var p Parser
+
+	t.Run("non-number type", func(t *testing.T) {
+		v, err := p.Parse(`"not a number"`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		_, err = v.Uint()
+		if err == nil {
+			t.Errorf("expected error for non-number type")
+		}
+	})
+}
+
+// TestUnescapeStringBestEffortFinal tests final edge cases in unescaping
+func TestUnescapeStringBestEffortFinal(t *testing.T) {
+	t.Run("empty string", func(t *testing.T) {
+		result := unescapeStringBestEffort(nil, "")
+		if result != "" {
+			t.Errorf("unescapeStringBestEffort(\"\") = %q, want \"\"", result)
+		}
+	})
+
+	t.Run("string with no escapes", func(t *testing.T) {
+		result := unescapeStringBestEffort(nil, "hello world")
+		if result != "hello world" {
+			t.Errorf("unescapeStringBestEffort(\"hello world\") = %q, want \"hello world\"", result)
+		}
+	})
+
+	t.Run("string with only escapes at end", func(t *testing.T) {
+		result := unescapeStringBestEffort(nil, "hello\\n")
+		if result != "hello\n" {
+			t.Errorf("unescapeStringBestEffort(\"hello\\n\") = %q, want \"hello\\n\"", result)
+		}
+	})
+}
+
+// TestGetIntGetUintOverflow tests overflow cases
+func TestGetIntGetUintOverflow(t *testing.T) {
+	var p Parser
+
+	t.Run("GetInt overflow", func(t *testing.T) {
+		// Test case where int64 doesn't fit in int
+		v, err := p.Parse(`9223372036854775807`) // Max int64
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		result := v.GetInt()
+		// On 64-bit systems, this should work, on 32-bit it should return 0
+		if result != 0 && result != 9223372036854775807 {
+			t.Errorf("unexpected result: %d", result)
+		}
+	})
+
+	t.Run("GetUint overflow", func(t *testing.T) {
+		// Test case where uint64 doesn't fit in uint
+		v, err := p.Parse(`18446744073709551615`) // Max uint64
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		result := v.GetUint()
+		// On 64-bit systems, this should work, on 32-bit it should return 0
+		if result != 0 && result != 18446744073709551615 {
+			t.Errorf("unexpected result: %d", result)
+		}
+	})
+}
diff --git a/update.go b/update.go
index 18899b8..058f8b8 100644
--- a/update.go
+++ b/update.go
@@ -12,21 +12,21 @@ func (o *Object) Del(key string) {
 	if o == nil {
 		return
 	}
-	if !o.keysUnescaped && strings.IndexByte(key, '\\') < 0 {
-		// Fast path - try searching for the key without object keys unescaping.
+	if strings.IndexByte(key, '\\') < 0 {
+		// Fast path - try searching for the key without unescaping
 		for i, kv := range o.kvs {
-			if kv.k == key {
+			if !kv.keyUnescaped && kv.k == key {
 				o.kvs = append(o.kvs[:i], o.kvs[i+1:]...)
 				return
 			}
 		}
 	}
 
-	// Slow path - unescape object keys before item search.
-	// Note: Passing nil arena is safe - go-arena falls back to heap allocation when arena is nil.
-	o.unescapeKeys(nil)
-
+	// Slow path - unescape keys as needed and search
 	for i, kv := range o.kvs {
+		if !kv.keyUnescaped {
+			o.unescapeKey(nil, kv)
+		}
 		if kv.k == key {
 			o.kvs = append(o.kvs[:i], o.kvs[i+1:]...)
 			return
@@ -62,10 +62,12 @@ func (o *Object) Set(a arena.Arena, key string, value *Value) {
 	if value == nil {
 		value = valueNull
 	}
-	o.unescapeKeys(a)
 
 	// Try substituting already existing entry with the given key.
 	for i := range o.kvs {
+		if !o.kvs[i].keyUnescaped {
+			o.unescapeKey(a, o.kvs[i])
+		}
 		if o.kvs[i].k == key {
 			o.kvs[i].v = value
 			return
@@ -76,6 +78,7 @@ func (o *Object) Set(a arena.Arena, key string, value *Value) {
 	kv := o.getKV(a)
 	kv.k = key
 	kv.v = value
+	kv.keyUnescaped = true // New keys are already unescaped since they come from user input
 }
 
 // Set sets (key, value) entry in the array or object v.
diff --git a/update_test.go b/update_test.go
index feb68cd..6f842d9 100644
--- a/update_test.go
+++ b/update_test.go
@@ -1,6 +1,7 @@
 package astjson
 
 import (
+	"strings"
 	"testing"
 
 	"github.com/wundergraph/go-arena"
@@ -119,6 +120,462 @@ func TestValue_AppendArrayItems(t *testing.T) {
 	}
 }
 
+func TestObjectSetComprehensive(t *testing.T) {
+	t.Run("nil object", func(t *testing.T) {
+		var o *Object
+		a := arena.NewMonotonicArena()
+		o.Set(a, "key", MustParse(`"value"`))
+		// Should not panic and should be no-op
+	})
+
+	t.Run("nil value becomes null", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{"existing": "value"}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		a := arena.NewMonotonicArena()
+
+		o.Set(a, "new_key", nil)
+		result := o.Get("new_key")
+		if result == nil {
+			t.Fatalf("expected non-nil result")
+		}
+		if result.Type() != TypeNull {
+			t.Fatalf("expected null type, got %s", result.Type())
+		}
+	})
+
+	t.Run("set new key", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{"existing": "value"}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		a := arena.NewMonotonicArena()
+
+		newValue := MustParse(`"new_value"`)
+		o.Set(a, "new_key", newValue)
+
+		result := o.Get("new_key")
+		if result == nil {
+			t.Fatalf("expected non-nil result")
+		}
+		if string(result.GetStringBytes()) != "new_value" {
+			t.Fatalf("expected 'new_value', got %q", string(result.GetStringBytes()))
+		}
+
+		// Verify the key was marked as unescaped
+		for _, kv := range o.kvs {
+			if kv.k == "new_key" && !kv.keyUnescaped {
+				t.Fatalf("expected new key to be marked as unescaped")
+			}
+		}
+	})
+
+	t.Run("update existing key", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{"existing": "old_value"}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		a := arena.NewMonotonicArena()
+
+		newValue := MustParse(`"new_value"`)
+		o.Set(a, "existing", newValue)
+
+		result := o.Get("existing")
+		if result == nil {
+			t.Fatalf("expected non-nil result")
+		}
+		if string(result.GetStringBytes()) != "new_value" {
+			t.Fatalf("expected 'new_value', got %q", string(result.GetStringBytes()))
+		}
+
+		// Verify object length didn't change
+		if o.Len() != 1 {
+			t.Fatalf("expected length 1, got %d", o.Len())
+		}
+	})
+
+	t.Run("set key with escape sequences", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{"normal_key": "value"}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		a := arena.NewMonotonicArena()
+
+		// Set a key that contains escape sequences
+		o.Set(a, "key\\with\\escapes", MustParse(`"escaped_value"`))
+
+		result := o.Get("key\\with\\escapes")
+		if result == nil {
+			t.Fatalf("expected non-nil result")
+		}
+		if string(result.GetStringBytes()) != "escaped_value" {
+			t.Fatalf("expected 'escaped_value', got %q", string(result.GetStringBytes()))
+		}
+	})
+
+	t.Run("update existing escaped key", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{"key\\with\\escapes": "old_value"}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		a := arena.NewMonotonicArena()
+
+		// Update the existing escaped key
+		o.Set(a, "key\\with\\escapes", MustParse(`"new_value"`))
+
+		result := o.Get("key\\with\\escapes")
+		if result == nil {
+			t.Fatalf("expected non-nil result")
+		}
+		if string(result.GetStringBytes()) != "new_value" {
+			t.Fatalf("expected 'new_value', got %q", string(result.GetStringBytes()))
+		}
+	})
+
+	t.Run("set multiple keys", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		a := arena.NewMonotonicArena()
+
+		// Set multiple keys
+		o.Set(a, "key1", MustParse(`"value1"`))
+		o.Set(a, "key2", MustParse(`"value2"`))
+		o.Set(a, "key3", MustParse(`"value3"`))
+
+		if o.Len() != 3 {
+			t.Fatalf("expected length 3, got %d", o.Len())
+		}
+
+		// Verify all keys are accessible
+		if string(o.Get("key1").GetStringBytes()) != "value1" {
+			t.Fatalf("unexpected value for key1")
+		}
+		if string(o.Get("key2").GetStringBytes()) != "value2" {
+			t.Fatalf("unexpected value for key2")
+		}
+		if string(o.Get("key3").GetStringBytes()) != "value3" {
+			t.Fatalf("unexpected value for key3")
+		}
+	})
+
+	t.Run("set different value types", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		a := arena.NewMonotonicArena()
+
+		// Set different types of values
+		o.Set(a, "string_key", MustParse(`"string_value"`))
+		o.Set(a, "number_key", MustParse(`123`))
+		o.Set(a, "bool_key", MustParse(`true`))
+		o.Set(a, "null_key", MustParse(`null`))
+		o.Set(a, "array_key", MustParse(`[1,2,3]`))
+		o.Set(a, "object_key", MustParse(`{"nested": "value"}`))
+
+		if o.Len() != 6 {
+			t.Fatalf("expected length 6, got %d", o.Len())
+		}
+
+		// Verify types
+		if o.Get("string_key").Type() != TypeString {
+			t.Fatalf("expected string type")
+		}
+		if o.Get("number_key").Type() != TypeNumber {
+			t.Fatalf("expected number type")
+		}
+		if o.Get("bool_key").Type() != TypeTrue {
+			t.Fatalf("expected true type")
+		}
+		if o.Get("null_key").Type() != TypeNull {
+			t.Fatalf("expected null type")
+		}
+		if o.Get("array_key").Type() != TypeArray {
+			t.Fatalf("expected array type")
+		}
+		if o.Get("object_key").Type() != TypeObject {
+			t.Fatalf("expected object type")
+		}
+	})
+
+	t.Run("set with nil arena", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{"existing": "value"}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+
+		// Set with nil arena should still work (falls back to heap allocation)
+		o.Set(nil, "new_key", MustParse(`"new_value"`))
+
+		result := o.Get("new_key")
+		if result == nil {
+			t.Fatalf("expected non-nil result")
+		}
+		if string(result.GetStringBytes()) != "new_value" {
+			t.Fatalf("expected 'new_value', got %q", string(result.GetStringBytes()))
+		}
+	})
+
+	t.Run("set empty key", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		a := arena.NewMonotonicArena()
+
+		o.Set(a, "", MustParse(`"empty_key_value"`))
+
+		result := o.Get("")
+		if result == nil {
+			t.Fatalf("expected non-nil result")
+		}
+		if string(result.GetStringBytes()) != "empty_key_value" {
+			t.Fatalf("expected 'empty_key_value', got %q", string(result.GetStringBytes()))
+		}
+	})
+
+	t.Run("set key with special characters", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		a := arena.NewMonotonicArena()
+
+		specialKeys := []string{
+			"key with spaces",
+			"key-with-dashes",
+			"key_with_underscores",
+			"key.with.dots",
+			"key/with/slashes",
+			"key:with:colons",
+			"key;with;semicolons",
+			"key,with,commas",
+			"key[with]brackets",
+			"key{with}braces",
+			"key(with)parentheses",
+			"key<with>angles",
+			"key\"with\"quotes",
+			"key'with'apostrophes",
+			"key\nwith\nnewlines",
+			"key\twith\ttabs",
+			"key\rwith\rcarriage",
+		}
+
+		for i, key := range specialKeys {
+			o.Set(a, key, MustParse(`"value"`))
+			result := o.Get(key)
+			if result == nil {
+				t.Fatalf("expected non-nil result for key %d: %q", i, key)
+			}
+		}
+
+		if o.Len() != len(specialKeys) {
+			t.Fatalf("expected length %d, got %d", len(specialKeys), o.Len())
+		}
+	})
+
+	t.Run("set unicode keys", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		a := arena.NewMonotonicArena()
+
+		unicodeKeys := []string{
+			"ключ",       // Russian
+			"键",          // Chinese
+			"キー",         // Japanese
+			"مفتاح",      // Arabic
+			"🔑",          // Emoji
+			"café",       // French with accent
+			"naïve",      // French with diaeresis
+			"café naïve", // Combined
+		}
+
+		for i, key := range unicodeKeys {
+			o.Set(a, key, MustParse(`"value"`))
+			result := o.Get(key)
+			if result == nil {
+				t.Fatalf("expected non-nil result for unicode key %d: %q", i, key)
+			}
+		}
+
+		if o.Len() != len(unicodeKeys) {
+			t.Fatalf("expected length %d, got %d", len(unicodeKeys), o.Len())
+		}
+	})
+}
+
+func TestObjectSetEdgeCases(t *testing.T) {
+	t.Run("set same key multiple times", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		a := arena.NewMonotonicArena()
+
+		// Set the same key multiple times
+		o.Set(a, "key", MustParse(`"value1"`))
+		o.Set(a, "key", MustParse(`"value2"`))
+		o.Set(a, "key", MustParse(`"value3"`))
+
+		if o.Len() != 1 {
+			t.Fatalf("expected length 1, got %d", o.Len())
+		}
+
+		result := o.Get("key")
+		if result == nil {
+			t.Fatalf("expected non-nil result")
+		}
+		if string(result.GetStringBytes()) != "value3" {
+			t.Fatalf("expected 'value3', got %q", string(result.GetStringBytes()))
+		}
+	})
+
+	t.Run("set after get operation", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{"existing": "value"}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		a := arena.NewMonotonicArena()
+
+		// Get existing key (this might trigger unescaping)
+		existing := o.Get("existing")
+		if existing == nil {
+			t.Fatalf("expected non-nil result")
+		}
+
+		// Now set a new key
+		o.Set(a, "new_key", MustParse(`"new_value"`))
+
+		result := o.Get("new_key")
+		if result == nil {
+			t.Fatalf("expected non-nil result")
+		}
+		if string(result.GetStringBytes()) != "new_value" {
+			t.Fatalf("expected 'new_value', got %q", string(result.GetStringBytes()))
+		}
+	})
+
+	t.Run("set with very long key", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		a := arena.NewMonotonicArena()
+
+		// Create a very long key
+		longKey := strings.Repeat("a", 10000)
+		o.Set(a, longKey, MustParse(`"value"`))
+
+		result := o.Get(longKey)
+		if result == nil {
+			t.Fatalf("expected non-nil result")
+		}
+		if string(result.GetStringBytes()) != "value" {
+			t.Fatalf("expected 'value', got %q", string(result.GetStringBytes()))
+		}
+	})
+
+	t.Run("set with very long value", func(t *testing.T) {
+		var p Parser
+		v, err := p.Parse(`{}`)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		o, err := v.Object()
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		a := arena.NewMonotonicArena()
+
+		// Create a very long value
+		longValue := strings.Repeat("x", 10000)
+		o.Set(a, "key", MustParse(`"`+longValue+`"`))
+
+		result := o.Get("key")
+		if result == nil {
+			t.Fatalf("expected non-nil result")
+		}
+		if string(result.GetStringBytes()) != longValue {
+			t.Fatalf("expected long value, got different length: %d", len(string(result.GetStringBytes())))
+		}
+	})
+}
+
 func TestObjectDelWithNilArena(t *testing.T) {
 	// Test that Del method works correctly when unescapeKeys is called with nil arena
 	var p Parser