diff --git a/cmd/wasm/functions.go b/cmd/wasm/functions.go
index 59f35f1..0a1cdef 100644
--- a/cmd/wasm/functions.go
+++ b/cmd/wasm/functions.go
@@ -3,10 +3,13 @@
 package main
 
 import (
+	"encoding/json"
 	"fmt"
 	"github.com/speakeasy-api/jsonpath/pkg/jsonpath"
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 	"github.com/speakeasy-api/jsonpath/pkg/overlay"
 	"gopkg.in/yaml.v3"
+	"reflect"
 	"syscall/js"
 )
 
@@ -27,7 +30,7 @@ func CalculateOverlay(originalYAML, targetYAML, existingOverlay string) (string,
 	var existingOverlayDocument overlay.Overlay
 	err = yaml.Unmarshal([]byte(existingOverlay), &existingOverlayDocument)
 	if err != nil {
-		return "", fmt.Errorf("failed to parse overlay schema: %w", err)
+		return "", fmt.Errorf("failed to parse overlay schema in CalculateOverlay: %w", err)
 	}
 	// now modify the original using the existing overlay
 	err = existingOverlayDocument.ApplyTo(&orig)
@@ -88,6 +91,11 @@ func GetInfo(originalYAML string) (string, error) {
 }`, nil
 }
 
+type ApplyOverlaySuccess struct {
+	Type   string `json:"type"`
+	Result string `json:"result"`
+}
+
 func ApplyOverlay(originalYAML, overlayYAML string) (string, error) {
 	var orig yaml.Node
 	err := yaml.Unmarshal([]byte(originalYAML), &orig)
@@ -98,7 +106,31 @@ func ApplyOverlay(originalYAML, overlayYAML string) (string, error) {
 	var overlay overlay.Overlay
 	err = yaml.Unmarshal([]byte(overlayYAML), &overlay)
 	if err != nil {
-		return "", fmt.Errorf("failed to parse overlay schema: %w", err)
+		return "", fmt.Errorf("failed to parse overlay schema in ApplyOverlay: %w", err)
+	}
+
+	// check to see if we have an overlay with an error, or a partial overlay: i.e. any overlay actions are missing an update or remove
+	for i, action := range overlay.Actions {
+		parsed, pathErr := jsonpath.NewPath(action.Target, config.WithPropertyNameExtension())
+		var node *yaml.Node
+		if pathErr != nil {
+			node, err = lookupOverlayActionTargetNode(overlayYAML, i)
+			if err != nil {
+				return "", err
+			}
+
+			return applyOverlayJSONPathError(pathErr, node)
+		}
+		if reflect.ValueOf(action.Update).IsZero() && action.Remove == false {
+			result := parsed.Query(&orig)
+
+			node, err = lookupOverlayActionTargetNode(overlayYAML, i)
+			if err != nil {
+				return "", err
+			}
+
+			return applyOverlayJSONPathIncomplete(result, node)
+		}
 	}
 
 	err = overlay.ApplyTo(&orig)
@@ -116,6 +148,88 @@ func ApplyOverlay(originalYAML, overlayYAML string) (string, error) {
 		return "", fmt.Errorf("failed to marshal result: %w", err)
 	}
 
+	out, err = json.Marshal(ApplyOverlaySuccess{
+		Type:   "success",
+		Result: string(out),
+	})
+
+	return string(out), err
+}
+
+type IncompleteOverlayErrorMessage struct {
+	Type   string `json:"type"`
+	Line   int    `json:"line"`
+	Col    int    `json:"col"`
+	Result string `json:"result"`
+}
+
+func applyOverlayJSONPathIncomplete(result []*yaml.Node, node *yaml.Node) (string, error) {
+	yamlResult, err := yaml.Marshal(result)
+	if err != nil {
+		return "", err
+	}
+	out, err := json.Marshal(IncompleteOverlayErrorMessage{
+		Type:   "incomplete",
+		Line:   node.Line,
+		Col:    node.Column,
+		Result: string(yamlResult),
+	})
+	return string(out), err
+}
+
+type JSONPathErrorMessage struct {
+	Type       string `json:"type"`
+	Line       int    `json:"line"`
+	Col        int    `json:"col"`
+	ErrMessage string `json:"error"`
+}
+
+func applyOverlayJSONPathError(err error, node *yaml.Node) (string, error) {
+	// first lets see if we can find a target expression
+	out, err := json.Marshal(JSONPathErrorMessage{
+		Type:       "error",
+		Line:       node.Line,
+		Col:        node.Column,
+		ErrMessage: err.Error(),
+	})
+	return string(out), err
+}
+
+func lookupOverlayActionTargetNode(overlayYAML string, i int) (*yaml.Node, error) {
+	var node struct {
+		Actions []struct {
+			Target yaml.Node `yaml:"target"`
+		} `yaml:"actions"`
+	}
+	err := yaml.Unmarshal([]byte(overlayYAML), &node)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse overlay schema in lookupOverlayActionTargetNode: %w", err)
+	}
+	if len(node.Actions) <= i {
+		return nil, fmt.Errorf("no action at index %d", i)
+	}
+	if reflect.ValueOf(node.Actions[i].Target).IsZero() {
+		return nil, fmt.Errorf("no target at index %d", i)
+	}
+	return &node.Actions[i].Target, nil
+}
+
+func Query(currentYAML, path string) (string, error) {
+	var orig yaml.Node
+	err := yaml.Unmarshal([]byte(currentYAML), &orig)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse original schema in Query: %w", err)
+	}
+	parsed, err := jsonpath.NewPath(path, config.WithPropertyNameExtension())
+	if err != nil {
+		return "", err
+	}
+	result := parsed.Query(&orig)
+	// Marshal it back out
+	out, err := yaml.Marshal(result)
+	if err != nil {
+		return "", err
+	}
 	return string(out), nil
 }
 
@@ -173,6 +287,13 @@ func main() {
 
 		return GetInfo(args[0].String())
 	}))
+	js.Global().Set("QueryJSONPath", promisify(func(args []js.Value) (string, error) {
+		if len(args) != 1 {
+			return "", fmt.Errorf("Query: expected 2 args, got %v", len(args))
+		}
+
+		return Query(args[0].String(), args[1].String())
+	}))
 
 	<-make(chan bool)
 }
diff --git a/pkg/jsonpath/config/config.go b/pkg/jsonpath/config/config.go
new file mode 100644
index 0000000..bd8286c
--- /dev/null
+++ b/pkg/jsonpath/config/config.go
@@ -0,0 +1,31 @@
+package config
+
+type Option func(*config)
+
+// WithPropertyNameExtension enables the use of the "~" character to access a property key.
+// It is not enabled by default as this is outside of RFC 9535, but is important for several use-cases
+func WithPropertyNameExtension() Option {
+	return func(cfg *config) {
+		cfg.propertyNameExtension = true
+	}
+}
+
+type Config interface {
+	PropertyNameEnabled() bool
+}
+
+type config struct {
+	propertyNameExtension bool
+}
+
+func (c *config) PropertyNameEnabled() bool {
+	return c.propertyNameExtension
+}
+
+func New(opts ...Option) Config {
+	cfg := &config{}
+	for _, opt := range opts {
+		opt(cfg)
+	}
+	return cfg
+}
diff --git a/pkg/jsonpath/filter.go b/pkg/jsonpath/filter.go
index 2f17c24..0f5b77f 100644
--- a/pkg/jsonpath/filter.go
+++ b/pkg/jsonpath/filter.go
@@ -103,11 +103,11 @@ type resolvedArgument struct {
 	nodes   []*literal
 }
 
-func (a functionArgument) Eval(node *yaml.Node, root *yaml.Node) resolvedArgument {
+func (a functionArgument) Eval(idx index, node *yaml.Node, root *yaml.Node) resolvedArgument {
 	if a.literal != nil {
 		return resolvedArgument{kind: functionArgTypeLiteral, literal: a.literal}
 	} else if a.filterQuery != nil {
-		result := a.filterQuery.Query(node, root)
+		result := a.filterQuery.Query(idx, node, root)
 		lits := make([]*literal, len(result))
 		for i, node := range result {
 			lit := nodeToLiteral(node)
@@ -119,10 +119,10 @@ func (a functionArgument) Eval(node *yaml.Node, root *yaml.Node) resolvedArgumen
 			return resolvedArgument{kind: functionArgTypeLiteral, literal: lits[0]}
 		}
 	} else if a.logicalExpr != nil {
-		res := a.logicalExpr.Matches(node, root)
+		res := a.logicalExpr.Matches(idx, node, root)
 		return resolvedArgument{kind: functionArgTypeLiteral, literal: &literal{bool: &res}}
 	} else if a.functionExpr != nil {
-		res := a.functionExpr.Evaluate(node, root)
+		res := a.functionExpr.Evaluate(idx, node, root)
 		return resolvedArgument{kind: functionArgTypeLiteral, literal: &res}
 	}
 	return resolvedArgument{}
diff --git a/pkg/jsonpath/jsonpath.go b/pkg/jsonpath/jsonpath.go
index 22d2192..d5c8a5b 100644
--- a/pkg/jsonpath/jsonpath.go
+++ b/pkg/jsonpath/jsonpath.go
@@ -2,19 +2,20 @@ package jsonpath
 
 import (
 	"fmt"
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/token"
 	"gopkg.in/yaml.v3"
 )
 
-func NewPath(input string) (*JSONPath, error) {
-	tokenizer := token.NewTokenizer(input)
+func NewPath(input string, opts ...config.Option) (*JSONPath, error) {
+	tokenizer := token.NewTokenizer(input, opts...)
 	tokens := tokenizer.Tokenize()
 	for i := 0; i < len(tokens); i++ {
 		if tokens[i].Token == token.ILLEGAL {
 			return nil, fmt.Errorf(tokenizer.ErrorString(&tokens[i], "unexpected token"))
 		}
 	}
-	parser := newParserPrivate(tokenizer, tokens)
+	parser := newParserPrivate(tokenizer, tokens, opts...)
 	err := parser.parse()
 	if err != nil {
 		return nil, err
diff --git a/pkg/jsonpath/parser.go b/pkg/jsonpath/parser.go
index d8f15f6..5a30a91 100644
--- a/pkg/jsonpath/parser.go
+++ b/pkg/jsonpath/parser.go
@@ -3,6 +3,7 @@ package jsonpath
 import (
 	"errors"
 	"fmt"
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/token"
 	"strconv"
 	"strings"
@@ -24,11 +25,12 @@ type JSONPath struct {
 	ast       jsonPathAST
 	current   int
 	mode      []mode
+	config    config.Config
 }
 
 // newParserPrivate creates a new JSONPath with the given tokens.
-func newParserPrivate(tokenizer *token.Tokenizer, tokens []token.TokenInfo) *JSONPath {
-	return &JSONPath{tokenizer, tokens, jsonPathAST{}, 0, []mode{modeNormal}}
+func newParserPrivate(tokenizer *token.Tokenizer, tokens []token.TokenInfo, opts ...config.Option) *JSONPath {
+	return &JSONPath{tokenizer, tokens, jsonPathAST{}, 0, []mode{modeNormal}, config.New(opts...)}
 }
 
 // parse parses the JSONPath tokens and returns the root node of the AST.
@@ -88,7 +90,7 @@ func (p *JSONPath) parseSegment() (*segment, error) {
 		if err != nil {
 			return nil, err
 		}
-		return &segment{Descendant: child}, nil
+		return &segment{kind: segmentKindDescendant, descendant: child}, nil
 	} else if currentToken.Token == token.CHILD || currentToken.Token == token.BRACKET_LEFT {
 		if currentToken.Token == token.CHILD {
 			p.current++
@@ -97,7 +99,10 @@ func (p *JSONPath) parseSegment() (*segment, error) {
 		if err != nil {
 			return nil, err
 		}
-		return &segment{Child: child}, nil
+		return &segment{kind: segmentKindChild, child: child}, nil
+	} else if p.config.PropertyNameEnabled() && currentToken.Token == token.PROPERTY_NAME {
+		p.current++
+		return &segment{kind: segmentKindProperyName}, nil
 	}
 	return nil, p.parseFailure(&currentToken, "unexpected token when parsing segment")
 }
diff --git a/pkg/jsonpath/parser_test.go b/pkg/jsonpath/parser_test.go
index a4f367b..d234519 100644
--- a/pkg/jsonpath/parser_test.go
+++ b/pkg/jsonpath/parser_test.go
@@ -2,6 +2,7 @@ package jsonpath_test
 
 import (
 	"github.com/speakeasy-api/jsonpath/pkg/jsonpath"
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 	"github.com/stretchr/testify/require"
 	"testing"
 )
@@ -89,3 +90,84 @@ func TestParser(t *testing.T) {
 		})
 	}
 }
+
+func TestParserPropertyNameExtension(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   string
+		enabled bool
+		valid   bool
+	}{
+		{
+			name:    "Simple property name disabled",
+			input:   "$.store~",
+			enabled: false,
+			valid:   false,
+		},
+		{
+			name:    "Simple property name enabled",
+			input:   "$.store~",
+			enabled: true,
+			valid:   true,
+		},
+		{
+			name:    "Property name in filter disabled",
+			input:   "$[?(@~)]",
+			enabled: false,
+			valid:   false,
+		},
+		{
+			name:    "Property name in filter enabled",
+			input:   "$[?(@~)]",
+			enabled: true,
+			valid:   true,
+		},
+		{
+			name:    "Property name with bracket notation enabled",
+			input:   "$['store']~",
+			enabled: true,
+			valid:   true,
+		},
+		{
+			name:    "Property name with bracket notation disabled",
+			input:   "$['store']~",
+			enabled: false,
+			valid:   false,
+		},
+		{
+			name:    "Chained property names enabled",
+			input:   "$.store~.name~",
+			enabled: true,
+			valid:   true,
+		},
+		{
+			name:    "Property name in complex filter enabled",
+			input:   "$[?(@~ && @.price < 10)]",
+			enabled: true,
+			valid:   true,
+		},
+		{
+			name:    "Property name in complex filter disabled",
+			input:   "$[?(@~ && @.price < 10)]",
+			enabled: false,
+			valid:   false,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			var opts []config.Option
+			if test.enabled {
+				opts = append(opts, config.WithPropertyNameExtension())
+			}
+
+			path, err := jsonpath.NewPath(test.input, opts...)
+			if !test.valid {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			require.Equal(t, test.input, path.String())
+		})
+	}
+}
diff --git a/pkg/jsonpath/segment.go b/pkg/jsonpath/segment.go
index 42876df..cb6233f 100644
--- a/pkg/jsonpath/segment.go
+++ b/pkg/jsonpath/segment.go
@@ -5,9 +5,18 @@ import (
 	"strings"
 )
 
+type segmentKind int
+
+const (
+	segmentKindChild       segmentKind = iota // .
+	segmentKindDescendant                     // ..
+	segmentKindProperyName                    // ~ (extension only)
+)
+
 type segment struct {
-	Child      *innerSegment
-	Descendant *innerSegment
+	kind       segmentKind
+	child      *innerSegment
+	descendant *innerSegment
 }
 
 type segmentSubKind int
@@ -19,17 +28,19 @@ const (
 )
 
 func (s segment) ToString() string {
-	if s.Child != nil {
-		if s.Child.kind != segmentLongHand {
-			return "." + s.Child.ToString()
+	switch s.kind {
+	case segmentKindChild:
+		if s.child.kind != segmentLongHand {
+			return "." + s.child.ToString()
 		} else {
-			return s.Child.ToString()
+			return s.child.ToString()
 		}
-	} else if s.Descendant != nil {
-		return ".." + s.Descendant.ToString()
-	} else {
-		panic("no segment")
+	case segmentKindDescendant:
+		return ".." + s.descendant.ToString()
+	case segmentKindProperyName:
+		return "~"
 	}
+	panic("unknown segment kind")
 }
 
 type innerSegment struct {
diff --git a/pkg/jsonpath/token/token.go b/pkg/jsonpath/token/token.go
index 2a0c0cb..948a719 100644
--- a/pkg/jsonpath/token/token.go
+++ b/pkg/jsonpath/token/token.go
@@ -2,6 +2,7 @@ package token
 
 import (
 	"fmt"
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 	"strconv"
 	"strings"
 )
@@ -172,6 +173,7 @@ const (
 	ROOT
 	CURRENT
 	WILDCARD
+	PROPERTY_NAME
 	RECURSIVE
 	CHILD
 	ARRAY_SLICE
@@ -391,14 +393,17 @@ type Tokenizer struct {
 	tokens            []TokenInfo
 	stack             []Token
 	illegalWhitespace bool
+	config            config.Config
 }
 
 // NewTokenizer creates a new JSONPath tokenizer for the given input string.
-func NewTokenizer(input string) *Tokenizer {
+func NewTokenizer(input string, opts ...config.Option) *Tokenizer {
+	cfg := config.New(opts...)
 	return &Tokenizer{
-		input: input,
-		line:  1,
-		stack: make([]Token, 0),
+		input:  input,
+		config: cfg,
+		line:   1,
+		stack:  make([]Token, 0),
 	}
 }
 
@@ -419,6 +424,12 @@ func (t *Tokenizer) Tokenize() Tokens {
 			t.addToken(CURRENT, 1, "")
 		case ch == '*':
 			t.addToken(WILDCARD, 1, "")
+		case ch == '~':
+			if t.config.PropertyNameEnabled() {
+				t.addToken(PROPERTY_NAME, 1, "")
+			} else {
+				t.addToken(ILLEGAL, 1, "invalid property name token without config.PropertyNameExtension set to true")
+			}
 		case ch == '.':
 			if t.peek() == '.' {
 				t.addToken(RECURSIVE, 2, "")
diff --git a/pkg/jsonpath/token/token_test.go b/pkg/jsonpath/token/token_test.go
index 0070726..459350d 100644
--- a/pkg/jsonpath/token/token_test.go
+++ b/pkg/jsonpath/token/token_test.go
@@ -2,6 +2,7 @@ package token
 
 import (
 	"fmt"
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 	"testing"
 )
 
@@ -19,7 +20,7 @@ func TestTokenizer(t *testing.T) {
 			},
 		},
 		{
-			name:  "Child",
+			name:  "child",
 			input: "$.store.book",
 			expected: []TokenInfo{
 				{Token: ROOT, Line: 1, Column: 0, Literal: "", Len: 1},
@@ -709,3 +710,93 @@ func TestString(t *testing.T) {
 		})
 	}
 }
+
+func TestPropertyNameExtension(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		enabled  bool
+		expected []TokenInfo
+	}{
+		{
+			name:    "Property name extension enabled",
+			input:   "$.child~",
+			enabled: true,
+			expected: []TokenInfo{
+				{Token: ROOT, Line: 1, Column: 0, Literal: "", Len: 1},
+				{Token: CHILD, Line: 1, Column: 1, Literal: "", Len: 1},
+				{Token: STRING, Line: 1, Column: 2, Literal: "child", Len: 5},
+				{Token: PROPERTY_NAME, Line: 1, Column: 7, Literal: "", Len: 1},
+			},
+		},
+		{
+			name:    "Property name extension disabled",
+			input:   "$.child~",
+			enabled: false,
+			expected: []TokenInfo{
+				{Token: ROOT, Line: 1, Column: 0, Literal: "", Len: 1},
+				{Token: CHILD, Line: 1, Column: 1, Literal: "", Len: 1},
+				{Token: STRING, Line: 1, Column: 2, Literal: "child", Len: 5},
+				{Token: ILLEGAL, Line: 1, Column: 7, Literal: "invalid property name token without config.PropertyNameExtension set to true", Len: 1},
+			},
+		},
+		{
+			name:    "Property name extension with bracket notation enabled",
+			input:   "$['child']~",
+			enabled: true,
+			expected: []TokenInfo{
+				{Token: ROOT, Line: 1, Column: 0, Literal: "", Len: 1},
+				{Token: BRACKET_LEFT, Line: 1, Column: 1, Literal: "", Len: 1},
+				{Token: STRING_LITERAL, Line: 1, Column: 2, Literal: "child", Len: 7},
+				{Token: BRACKET_RIGHT, Line: 1, Column: 9, Literal: "", Len: 1},
+				{Token: PROPERTY_NAME, Line: 1, Column: 10, Literal: "", Len: 1},
+			},
+		},
+		{
+			name:    "Property name extension in filter with current node",
+			input:   "$[?(@~)]",
+			enabled: true,
+			expected: []TokenInfo{
+				{Token: ROOT, Line: 1, Column: 0, Literal: "", Len: 1},
+				{Token: BRACKET_LEFT, Line: 1, Column: 1, Literal: "", Len: 1},
+				{Token: FILTER, Line: 1, Column: 2, Literal: "", Len: 1},
+				{Token: PAREN_LEFT, Line: 1, Column: 3, Literal: "", Len: 1},
+				{Token: CURRENT, Line: 1, Column: 4, Literal: "", Len: 1},
+				{Token: PROPERTY_NAME, Line: 1, Column: 5, Literal: "", Len: 1},
+				{Token: PAREN_RIGHT, Line: 1, Column: 6, Literal: "", Len: 1},
+				{Token: BRACKET_RIGHT, Line: 1, Column: 7, Literal: "", Len: 1},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			var tokenizer *Tokenizer
+			if test.enabled {
+				tokenizer = NewTokenizer(test.input, config.WithPropertyNameExtension())
+			} else {
+				tokenizer = NewTokenizer(test.input)
+			}
+
+			tokens := tokenizer.Tokenize()
+
+			if len(tokens) != len(test.expected) {
+				t.Errorf("Expected %d tokens, got %d\n%s",
+					len(test.expected),
+					len(tokens),
+					tokenizer.ErrorTokenString(&tokens[0], "Unexpected number of tokens"))
+			}
+
+			for i, expectedToken := range test.expected {
+				if i >= len(tokens) {
+					break
+				}
+				actualToken := tokens[i]
+				if actualToken != expectedToken {
+					t.Error(tokenizer.ErrorString(&actualToken,
+						fmt.Sprintf("Expected token %+v, got %+v", expectedToken, actualToken)))
+				}
+			}
+		})
+	}
+}
diff --git a/pkg/jsonpath/yaml_eval.go b/pkg/jsonpath/yaml_eval.go
index 3601dae..7291ea9 100644
--- a/pkg/jsonpath/yaml_eval.go
+++ b/pkg/jsonpath/yaml_eval.go
@@ -104,21 +104,21 @@ func (l literal) LessThanOrEqual(value literal) bool {
 	return l.LessThan(value) || l.Equals(value)
 }
 
-func (c comparable) Evaluate(node *yaml.Node, root *yaml.Node) literal {
+func (c comparable) Evaluate(idx index, node *yaml.Node, root *yaml.Node) literal {
 	if c.literal != nil {
 		return *c.literal
 	}
 	if c.singularQuery != nil {
-		return c.singularQuery.Evaluate(node, root)
+		return c.singularQuery.Evaluate(idx, node, root)
 	}
 	if c.functionExpr != nil {
-		return c.functionExpr.Evaluate(node, root)
+		return c.functionExpr.Evaluate(idx, node, root)
 	}
 	return literal{}
 }
 
-func (e functionExpr) length(node *yaml.Node, root *yaml.Node) literal {
-	args := e.args[0].Eval(node, root)
+func (e functionExpr) length(idx index, node *yaml.Node, root *yaml.Node) literal {
+	args := e.args[0].Eval(idx, node, root)
 	if args.kind != functionArgTypeLiteral {
 		return literal{}
 	}
@@ -150,8 +150,8 @@ func (e functionExpr) length(node *yaml.Node, root *yaml.Node) literal {
 	return literal{}
 }
 
-func (e functionExpr) count(node *yaml.Node, root *yaml.Node) literal {
-	args := e.args[0].Eval(node, root)
+func (e functionExpr) count(idx index, node *yaml.Node, root *yaml.Node) literal {
+	args := e.args[0].Eval(idx, node, root)
 	if args.kind == functionArgTypeNodes {
 		res := len(args.nodes)
 		return literal{integer: &res}
@@ -161,9 +161,9 @@ func (e functionExpr) count(node *yaml.Node, root *yaml.Node) literal {
 	return literal{integer: &res}
 }
 
-func (e functionExpr) match(node *yaml.Node, root *yaml.Node) literal {
-	arg1 := e.args[0].Eval(node, root)
-	arg2 := e.args[1].Eval(node, root)
+func (e functionExpr) match(idx index, node *yaml.Node, root *yaml.Node) literal {
+	arg1 := e.args[0].Eval(idx, node, root)
+	arg2 := e.args[1].Eval(idx, node, root)
 	if arg1.kind != functionArgTypeLiteral || arg2.kind != functionArgTypeLiteral {
 		return literal{}
 	}
@@ -174,9 +174,9 @@ func (e functionExpr) match(node *yaml.Node, root *yaml.Node) literal {
 	return literal{bool: &matched}
 }
 
-func (e functionExpr) search(node *yaml.Node, root *yaml.Node) literal {
-	arg1 := e.args[0].Eval(node, root)
-	arg2 := e.args[1].Eval(node, root)
+func (e functionExpr) search(idx index, node *yaml.Node, root *yaml.Node) literal {
+	arg1 := e.args[0].Eval(idx, node, root)
+	arg2 := e.args[1].Eval(idx, node, root)
 	if arg1.kind != functionArgTypeLiteral || arg2.kind != functionArgTypeLiteral {
 		return literal{}
 	}
@@ -187,7 +187,7 @@ func (e functionExpr) search(node *yaml.Node, root *yaml.Node) literal {
 	return literal{bool: &matched}
 }
 
-func (e functionExpr) value(node *yaml.Node, root *yaml.Node) literal {
+func (e functionExpr) value(idx index, node *yaml.Node, root *yaml.Node) literal {
 	//	2.4.8.  value() Function Extension
 	//
 	//Parameters:
@@ -204,7 +204,7 @@ func (e functionExpr) value(node *yaml.Node, root *yaml.Node) literal {
 	//*  If the argument is the empty nodelist or contains multiple nodes,
 	//	the result is Nothing.
 
-	nodesType := e.args[0].Eval(node, root)
+	nodesType := e.args[0].Eval(idx, node, root)
 	if nodesType.kind == functionArgTypeLiteral {
 		return *nodesType.literal
 	} else if nodesType.kind == functionArgTypeNodes && len(nodesType.nodes) == 1 {
@@ -234,34 +234,34 @@ func nodeToLiteral(node *yaml.Node) literal {
 	}
 }
 
-func (e functionExpr) Evaluate(node *yaml.Node, root *yaml.Node) literal {
+func (e functionExpr) Evaluate(idx index, node *yaml.Node, root *yaml.Node) literal {
 	switch e.funcType {
 	case functionTypeLength:
-		return e.length(node, root)
+		return e.length(idx, node, root)
 	case functionTypeCount:
-		return e.count(node, root)
+		return e.count(idx, node, root)
 	case functionTypeMatch:
-		return e.match(node, root)
+		return e.match(idx, node, root)
 	case functionTypeSearch:
-		return e.search(node, root)
+		return e.search(idx, node, root)
 	case functionTypeValue:
-		return e.value(node, root)
+		return e.value(idx, node, root)
 	}
 	return literal{}
 }
 
-func (q singularQuery) Evaluate(node *yaml.Node, root *yaml.Node) literal {
+func (q singularQuery) Evaluate(idx index, node *yaml.Node, root *yaml.Node) literal {
 	if q.relQuery != nil {
-		return q.relQuery.Evaluate(node, root)
+		return q.relQuery.Evaluate(idx, node, root)
 	}
 	if q.absQuery != nil {
-		return q.absQuery.Evaluate(node, root)
+		return q.absQuery.Evaluate(idx, node, root)
 	}
 	return literal{}
 }
 
-func (q relQuery) Evaluate(node *yaml.Node, root *yaml.Node) literal {
-	result := q.Query(node, root)
+func (q relQuery) Evaluate(idx index, node *yaml.Node, root *yaml.Node) literal {
+	result := q.Query(idx, node, root)
 	if len(result) == 1 {
 		return nodeToLiteral(result[0])
 	}
@@ -269,8 +269,8 @@ func (q relQuery) Evaluate(node *yaml.Node, root *yaml.Node) literal {
 
 }
 
-func (q absQuery) Evaluate(node *yaml.Node, root *yaml.Node) literal {
-	result := q.Query(root, root)
+func (q absQuery) Evaluate(idx index, node *yaml.Node, root *yaml.Node) literal {
+	result := q.Query(idx, root, root)
 	if len(result) == 1 {
 		return nodeToLiteral(result[0])
 	}
diff --git a/pkg/jsonpath/yaml_eval_test.go b/pkg/jsonpath/yaml_eval_test.go
index ba3cb66..a74e97b 100644
--- a/pkg/jsonpath/yaml_eval_test.go
+++ b/pkg/jsonpath/yaml_eval_test.go
@@ -235,7 +235,7 @@ func TestComparableEvaluate(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			result := tc.comparable.Evaluate(tc.node, tc.root)
+			result := tc.comparable.Evaluate(&_index{}, tc.node, tc.root)
 			if !reflect.DeepEqual(result, tc.expected) {
 				t.Errorf("Expected %v, but got %v", tc.expected, result)
 			}
@@ -269,7 +269,7 @@ func TestSingularQueryEvaluate(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			result := tc.query.Evaluate(tc.node, tc.root)
+			result := tc.query.Evaluate(&_index{}, tc.node, tc.root)
 			if !reflect.DeepEqual(result, tc.expected) {
 				t.Errorf("Expected %v, but got %v", tc.expected, result)
 			}
@@ -293,8 +293,8 @@ func TestRelQueryEvaluate(t *testing.T) {
 			expected: literal{integer: intPtr(10)},
 		},
 		{
-			name:     "Child segment",
-			query:    relQuery{segments: []*segment{{Child: &innerSegment{kind: segmentDotMemberName, dotName: "foo"}}}},
+			name:     "child segment",
+			query:    relQuery{segments: []*segment{{kind: segmentKindChild, child: &innerSegment{kind: segmentDotMemberName, dotName: "foo"}}}},
 			node:     yamlNodeFromString(`{"foo": "bar"}`),
 			root:     yamlNodeFromString(`{"foo": "bar"}`),
 			expected: literal{string: stringPtr("bar")},
@@ -303,7 +303,7 @@ func TestRelQueryEvaluate(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			result := tc.query.Evaluate(tc.node, tc.root)
+			result := tc.query.Evaluate(&_index{}, tc.node, tc.root)
 			if !reflect.DeepEqual(result, tc.expected) {
 				t.Errorf("Expected %v, but got %v", tc.expected, result)
 			}
@@ -327,8 +327,8 @@ func TestAbsQueryEvaluate(t *testing.T) {
 			expected: literal{integer: intPtr(10)},
 		},
 		{
-			name:     "Child segment",
-			query:    absQuery{segments: []*segment{{Child: &innerSegment{kind: segmentDotMemberName, dotName: "foo"}}}},
+			name:     "child segment",
+			query:    absQuery{segments: []*segment{{kind: segmentKindChild, child: &innerSegment{kind: segmentDotMemberName, dotName: "foo"}}}},
 			node:     yamlNodeFromString(`{"foo": "bar"}`),
 			root:     yamlNodeFromString(`{"foo": "bar"}`),
 			expected: literal{string: stringPtr("bar")},
@@ -337,7 +337,7 @@ func TestAbsQueryEvaluate(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			result := tc.query.Evaluate(tc.node, tc.root)
+			result := tc.query.Evaluate(&_index{}, tc.node, tc.root)
 			if !reflect.DeepEqual(result, tc.expected) {
 				t.Errorf("Expected %v, but got %v", tc.expected, result)
 			}
diff --git a/pkg/jsonpath/yaml_query.go b/pkg/jsonpath/yaml_query.go
index c607938..808e952 100644
--- a/pkg/jsonpath/yaml_query.go
+++ b/pkg/jsonpath/yaml_query.go
@@ -8,10 +8,35 @@ type Evaluator interface {
 	Query(current *yaml.Node, root *yaml.Node) []*yaml.Node
 }
 
+type index interface {
+	setPropertyKey(key *yaml.Node, value *yaml.Node)
+	getPropertyKey(key *yaml.Node) *yaml.Node
+}
+
+type _index struct {
+	propertyKeys map[*yaml.Node]*yaml.Node
+}
+
+func (i *_index) setPropertyKey(key *yaml.Node, value *yaml.Node) {
+	if i != nil && i.propertyKeys != nil {
+		i.propertyKeys[key] = value
+	}
+}
+
+func (i *_index) getPropertyKey(key *yaml.Node) *yaml.Node {
+	if i != nil {
+		return i.propertyKeys[key]
+	}
+	return nil
+}
+
 // jsonPathAST can be Evaluated
 var _ Evaluator = jsonPathAST{}
 
 func (q jsonPathAST) Query(current *yaml.Node, root *yaml.Node) []*yaml.Node {
+	idx := _index{
+		propertyKeys: map[*yaml.Node]*yaml.Node{},
+	}
 	result := make([]*yaml.Node, 0)
 	// If the top level node is a documentnode, unwrap it
 	if root.Kind == yaml.DocumentNode && len(root.Content) == 1 {
@@ -22,29 +47,35 @@ func (q jsonPathAST) Query(current *yaml.Node, root *yaml.Node) []*yaml.Node {
 	for _, segment := range q.segments {
 		newValue := []*yaml.Node{}
 		for _, value := range result {
-			newValue = append(newValue, segment.Query(value, root)...)
+			newValue = append(newValue, segment.Query(&idx, value, root)...)
 		}
 		result = newValue
 	}
 	return result
 }
 
-func (s segment) Query(value *yaml.Node, root *yaml.Node) []*yaml.Node {
-	if s.Child != nil {
-		return s.Child.Query(value, root)
-	} else if s.Descendant != nil {
+func (s segment) Query(idx index, value *yaml.Node, root *yaml.Node) []*yaml.Node {
+	switch s.kind {
+	case segmentKindChild:
+		return s.child.Query(idx, value, root)
+	case segmentKindDescendant:
 		// run the inner segment against this node
 		var result = []*yaml.Node{}
 		children := descend(value, root)
 		for _, child := range children {
-			result = append(result, s.Descendant.Query(child, root)...)
+			result = append(result, s.descendant.Query(idx, child, root)...)
 		}
 		// make children unique by pointer value
 		result = unique(result)
 		return result
-	} else {
-		panic("no segment type")
+	case segmentKindProperyName:
+		found := idx.getPropertyKey(value)
+		if found != nil {
+			return []*yaml.Node{found}
+		}
+		return []*yaml.Node{}
 	}
+	panic("no segment type")
 }
 
 func unique(nodes []*yaml.Node) []*yaml.Node {
@@ -60,7 +91,7 @@ func unique(nodes []*yaml.Node) []*yaml.Node {
 	return res
 }
 
-func (s innerSegment) Query(value *yaml.Node, root *yaml.Node) []*yaml.Node {
+func (s innerSegment) Query(idx index, value *yaml.Node, root *yaml.Node) []*yaml.Node {
 	result := []*yaml.Node{}
 
 	switch s.kind {
@@ -72,6 +103,7 @@ func (s innerSegment) Query(value *yaml.Node, root *yaml.Node) []*yaml.Node {
 			// we just want to return the values
 			for i, child := range value.Content {
 				if i%2 == 1 {
+					idx.setPropertyKey(child, value.Content[i-1])
 					result = append(result, child)
 				}
 			}
@@ -91,6 +123,7 @@ func (s innerSegment) Query(value *yaml.Node, root *yaml.Node) []*yaml.Node {
 				val := value.Content[i+1]
 
 				if key.Value == s.dotName {
+					idx.setPropertyKey(val, key)
 					result = append(result, val)
 					break
 				}
@@ -100,7 +133,7 @@ func (s innerSegment) Query(value *yaml.Node, root *yaml.Node) []*yaml.Node {
 	case segmentLongHand:
 		// Handle long hand selectors
 		for _, selector := range s.selectors {
-			result = append(result, selector.Query(value, root)...)
+			result = append(result, selector.Query(idx, value, root)...)
 		}
 	default:
 		panic("unknown child segment kind")
@@ -110,7 +143,7 @@ func (s innerSegment) Query(value *yaml.Node, root *yaml.Node) []*yaml.Node {
 
 }
 
-func (s selector) Query(value *yaml.Node, root *yaml.Node) []*yaml.Node {
+func (s selector) Query(idx index, value *yaml.Node, root *yaml.Node) []*yaml.Node {
 	switch s.kind {
 	case selectorSubKindName:
 		if value.Kind != yaml.MappingNode {
@@ -124,6 +157,7 @@ func (s selector) Query(value *yaml.Node, root *yaml.Node) []*yaml.Node {
 				continue
 			}
 			if key == s.name {
+				idx.setPropertyKey(child, value.Content[i])
 				return []*yaml.Node{child}
 			}
 		}
@@ -147,6 +181,7 @@ func (s selector) Query(value *yaml.Node, root *yaml.Node) []*yaml.Node {
 			var result []*yaml.Node
 			for i, child := range value.Content {
 				if i%2 == 1 {
+					idx.setPropertyKey(child, value.Content[i-1])
 					result = append(result, child)
 				}
 			}
@@ -188,13 +223,14 @@ func (s selector) Query(value *yaml.Node, root *yaml.Node) []*yaml.Node {
 		switch value.Kind {
 		case yaml.MappingNode:
 			for i := 1; i < len(value.Content); i += 2 {
-				if s.filter.Matches(value.Content[i], root) {
+				idx.setPropertyKey(value.Content[i], value.Content[i-1])
+				if s.filter.Matches(idx, value.Content[i], root) {
 					result = append(result, value.Content[i])
 				}
 			}
 		case yaml.SequenceNode:
 			for _, child := range value.Content {
-				if s.filter.Matches(child, root) {
+				if s.filter.Matches(idx, child, root) {
 					result = append(result, child)
 				}
 			}
@@ -240,46 +276,46 @@ func bounds(start, end *int64, step, length int64) (int64, int64) {
 	return lower, upper
 }
 
-func (s filterSelector) Matches(node *yaml.Node, root *yaml.Node) bool {
-	return s.expression.Matches(node, root)
+func (s filterSelector) Matches(idx index, node *yaml.Node, root *yaml.Node) bool {
+	return s.expression.Matches(idx, node, root)
 }
 
-func (e logicalOrExpr) Matches(node *yaml.Node, root *yaml.Node) bool {
+func (e logicalOrExpr) Matches(idx index, node *yaml.Node, root *yaml.Node) bool {
 	for _, expr := range e.expressions {
-		if expr.Matches(node, root) {
+		if expr.Matches(idx, node, root) {
 			return true
 		}
 	}
 	return false
 }
 
-func (e logicalAndExpr) Matches(node *yaml.Node, root *yaml.Node) bool {
+func (e logicalAndExpr) Matches(idx index, node *yaml.Node, root *yaml.Node) bool {
 	for _, expr := range e.expressions {
-		if !expr.Matches(node, root) {
+		if !expr.Matches(idx, node, root) {
 			return false
 		}
 	}
 	return true
 }
 
-func (e basicExpr) Matches(node *yaml.Node, root *yaml.Node) bool {
+func (e basicExpr) Matches(idx index, node *yaml.Node, root *yaml.Node) bool {
 	if e.parenExpr != nil {
-		result := e.parenExpr.expr.Matches(node, root)
+		result := e.parenExpr.expr.Matches(idx, node, root)
 		if e.parenExpr.not {
 			return !result
 		}
 		return result
 	} else if e.comparisonExpr != nil {
-		return e.comparisonExpr.Matches(node, root)
+		return e.comparisonExpr.Matches(idx, node, root)
 	} else if e.testExpr != nil {
-		return e.testExpr.Matches(node, root)
+		return e.testExpr.Matches(idx, node, root)
 	}
 	return false
 }
 
-func (e comparisonExpr) Matches(node *yaml.Node, root *yaml.Node) bool {
-	leftValue := e.left.Evaluate(node, root)
-	rightValue := e.right.Evaluate(node, root)
+func (e comparisonExpr) Matches(idx index, node *yaml.Node, root *yaml.Node) bool {
+	leftValue := e.left.Evaluate(idx, node, root)
+	rightValue := e.right.Evaluate(idx, node, root)
 
 	switch e.op {
 	case equalTo:
@@ -299,12 +335,12 @@ func (e comparisonExpr) Matches(node *yaml.Node, root *yaml.Node) bool {
 	}
 }
 
-func (e testExpr) Matches(node *yaml.Node, root *yaml.Node) bool {
+func (e testExpr) Matches(idx index, node *yaml.Node, root *yaml.Node) bool {
 	var result bool
 	if e.filterQuery != nil {
-		result = len(e.filterQuery.Query(node, root)) > 0
+		result = len(e.filterQuery.Query(idx, node, root)) > 0
 	} else if e.functionExpr != nil {
-		funcResult := e.functionExpr.Evaluate(node, root)
+		funcResult := e.functionExpr.Evaluate(idx, node, root)
 		if funcResult.bool != nil {
 			result = *funcResult.bool
 		} else if funcResult.null == nil {
@@ -317,9 +353,9 @@ func (e testExpr) Matches(node *yaml.Node, root *yaml.Node) bool {
 	return result
 }
 
-func (q filterQuery) Query(node *yaml.Node, root *yaml.Node) []*yaml.Node {
+func (q filterQuery) Query(idx index, node *yaml.Node, root *yaml.Node) []*yaml.Node {
 	if q.relQuery != nil {
-		return q.relQuery.Query(node, root)
+		return q.relQuery.Query(idx, node, root)
 	}
 	if q.jsonPathQuery != nil {
 		return q.jsonPathQuery.Query(node, root)
@@ -327,24 +363,24 @@ func (q filterQuery) Query(node *yaml.Node, root *yaml.Node) []*yaml.Node {
 	return nil
 }
 
-func (q relQuery) Query(node *yaml.Node, root *yaml.Node) []*yaml.Node {
+func (q relQuery) Query(idx index, node *yaml.Node, root *yaml.Node) []*yaml.Node {
 	result := []*yaml.Node{node}
 	for _, seg := range q.segments {
 		var newResult []*yaml.Node
 		for _, value := range result {
-			newResult = append(newResult, seg.Query(value, root)...)
+			newResult = append(newResult, seg.Query(idx, value, root)...)
 		}
 		result = newResult
 	}
 	return result
 }
 
-func (q absQuery) Query(node *yaml.Node, root *yaml.Node) []*yaml.Node {
+func (q absQuery) Query(idx index, node *yaml.Node, root *yaml.Node) []*yaml.Node {
 	result := []*yaml.Node{root}
 	for _, seg := range q.segments {
 		var newResult []*yaml.Node
 		for _, value := range result {
-			newResult = append(newResult, seg.Query(value, root)...)
+			newResult = append(newResult, seg.Query(idx, value, root)...)
 		}
 		result = newResult
 	}
diff --git a/pkg/jsonpath/yaml_query_test.go b/pkg/jsonpath/yaml_query_test.go
index 0fb39c7..5269a6d 100644
--- a/pkg/jsonpath/yaml_query_test.go
+++ b/pkg/jsonpath/yaml_query_test.go
@@ -1,6 +1,7 @@
 package jsonpath
 
 import (
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/token"
 	"gopkg.in/yaml.v3"
 	"reflect"
@@ -131,3 +132,107 @@ func nodeToString(node *yaml.Node) string {
 	}
 	return strings.TrimSpace(builder.String())
 }
+
+func TestPropertyNameQuery(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		yaml     string
+		expected []string
+	}{
+		{
+			name:  "Simple property name",
+			input: "$.store~",
+			yaml: `
+store: book-store
+`,
+			expected: []string{"store"},
+		},
+		{
+			name:  "Property name in filter",
+			input: "$.items[?(@~ == 'a')]",
+			yaml: `
+items:
+  a: item1
+  b: item2
+`,
+			expected: []string{"item1"},
+		},
+		{
+			name:  "Chained property names",
+			input: "$.store.items[*].type~",
+			yaml: `
+store:
+  items:
+    - type: book
+      name: Book 1
+    - type: magazine
+      name: Magazine 1
+`,
+			expected: []string{"type", "type"},
+		},
+		{
+			name:  "Property name in a function",
+			input: "$.store.items[?(length(@~) == 2)].found",
+			yaml: `
+store:
+  items:
+    ab: { found: true } 
+    cdef: { found: false }
+`,
+			expected: []string{"true"},
+		},
+		{
+			name:  "Property name in a function inverse case",
+			input: "$.store.items[?(length(@~) != 2)].found",
+			yaml: `
+store:
+  items:
+    ab: { found: true } 
+    cdef: { found: false }
+`,
+			expected: []string{"false"},
+		},
+		{
+			name:  "Property name on nested objects",
+			input: "$.deeply.nested.object~",
+			yaml: `
+deeply:
+  nested:
+    object:
+      key1: value1
+      key2: value2
+`,
+			expected: []string{"object"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			var root yaml.Node
+			err := yaml.Unmarshal([]byte(test.yaml), &root)
+			if err != nil {
+				t.Errorf("Error parsing YAML: %v", err)
+				return
+			}
+
+			tokenizer := token.NewTokenizer(test.input, config.WithPropertyNameExtension())
+			parser := newParserPrivate(tokenizer, tokenizer.Tokenize(), config.WithPropertyNameExtension())
+			err = parser.parse()
+			if err != nil {
+				t.Errorf("Error parsing JSON ast: %v", err)
+				return
+			}
+
+			result := parser.ast.Query(&root, &root)
+			var actual []string
+			for _, node := range result {
+				actual = append(actual, nodeToString(node))
+			}
+
+			if !reflect.DeepEqual(actual, test.expected) {
+				t.Errorf("Expected:\n%v\nGot:\n%v", test.expected, actual)
+			}
+		})
+	}
+}
diff --git a/pkg/overlay/apply.go b/pkg/overlay/apply.go
index 6230424..7148a62 100644
--- a/pkg/overlay/apply.go
+++ b/pkg/overlay/apply.go
@@ -2,6 +2,7 @@ package overlay
 
 import (
 	"github.com/speakeasy-api/jsonpath/pkg/jsonpath"
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 	"gopkg.in/yaml.v3"
 )
 
@@ -31,7 +32,7 @@ func applyRemoveAction(root *yaml.Node, action Action) error {
 
 	idx := newParentIndex(root)
 
-	p, err := jsonpath.NewPath(action.Target)
+	p, err := jsonpath.NewPath(action.Target, config.WithPropertyNameExtension())
 	if err != nil {
 		return err
 	}
@@ -78,7 +79,7 @@ func applyUpdateAction(root *yaml.Node, action Action) error {
 		return nil
 	}
 
-	p, err := jsonpath.NewPath(action.Target)
+	p, err := jsonpath.NewPath(action.Target, config.WithPropertyNameExtension())
 	if err != nil {
 		return err
 	}
diff --git a/web/src/Playground.tsx b/web/src/Playground.tsx
index b012757..16291b3 100644
--- a/web/src/Playground.tsx
+++ b/web/src/Playground.tsx
@@ -8,7 +8,7 @@ import {
 } from "react";
 import "./App.css";
 import { Editor } from "./components/Editor";
-import { editor } from "monaco-editor";
+import {editor, MarkerSeverity} from "monaco-editor";
 import { ApplyOverlay, CalculateOverlay, GetInfo } from "./bridge";
 import { Alert } from "@speakeasy-api/moonshine";
 import { blankOverlay, petstore } from "./defaults";
@@ -44,11 +44,21 @@ function Playground() {
   const original = useRef(petstore);
   const changed = useRef("");
   const [changedLoading, setChangedLoading] = useState(false);
+  const [applyOverlayMode, setApplyOverlayMode] = useState<
+    "original+overlay" | "jsonpathexplorer"
+  >("original+overlay");
+  let appliedPanelTitle = "Original + Overlay";
+  if (applyOverlayMode == "jsonpathexplorer") {
+    appliedPanelTitle = "JSONPath Explorer";
+  }
   const result = useRef(blankOverlay);
   const [resultLoading, setResultLoading] = useState(false);
   const [error, setError] = useState("");
   const [shareUrl, setShareUrl] = useState("");
   const [shareUrlLoading, setShareUrlLoading] = useState(false);
+  const [overlayMarkers, setOverlayMarkers] = useState<editor.IMarkerData[]>(
+    [],
+  );
   const isSmallScreen = useMediaQuery("(max-width: 768px)");
   const clearError = useCallback(() => {
     setError("");
@@ -124,22 +134,34 @@ function Playground() {
             result.current,
             false,
           );
-          const info = await GetInfo(original.current, false);
-          posthog.capture("overlay.speakeasy.com:load-shared", {
-            openapi: JSON.parse(info),
-          });
-
-          changed.current = changedNew;
+          if (changedNew.type == "success") {
+            const info = await GetInfo(original.current, false);
+            posthog.capture("overlay.speakeasy.com:load-shared", {
+              openapi: JSON.parse(info),
+            });
+            changed.current = changedNew.result;
+          }
         } catch (error: any) {
           console.error("invalid share url:", error.message);
         }
       } else {
-        const changedNew = await ApplyOverlay(
-          original.current,
-          result.current,
-          false,
-        );
-        changed.current = changedNew;
+        try {
+          const changedNew = await ApplyOverlay(
+            original.current,
+            result.current,
+            false,
+          );
+          if (changedNew.type == "success") {
+            changed.current = changedNew.result;
+          }
+        } catch (e: unknown) {
+          if (e instanceof Error) {
+            setError(e.message);
+          } else {
+            setError(JSON.stringify(e));
+          }
+          console.error(e);
+        }
       }
       setReady(true);
     })();
@@ -200,13 +222,30 @@ function Playground() {
     async (value: string | undefined, _: editor.IModelContentChangedEvent) => {
       try {
         setChangedLoading(true);
-        result.current = value || "";
-        changed.current = await ApplyOverlay(
-          original.current,
-          value || "",
-          true,
-        );
-        setError("");
+        const result = await ApplyOverlay(original.current, value || "", true);
+        if (result.type == "success") {
+          setApplyOverlayMode("original+overlay");
+          changed.current = result.result || "";
+          setError("");
+          setOverlayMarkers([]);
+        } else if (result.type == "incomplete") {
+          setApplyOverlayMode("jsonpathexplorer");
+          changed.current = result.result || "";
+          setError("");
+          setOverlayMarkers([]);
+        } else if (result.type == "error") {
+          setApplyOverlayMode("jsonpathexplorer");
+          setOverlayMarkers([
+            {
+              startLineNumber: result.line,
+              endLineNumber: result.line,
+              startColumn: result.col,
+              endColumn: result.col + 1000, // end of line
+              message: result.error,
+              severity: MarkerSeverity.Error, // Use MarkerSeverity from Monaco
+            },
+          ]);
+        }
       } catch (e: unknown) {
         if (e instanceof Error) {
           setError(e.message);
@@ -387,11 +426,15 @@ function Playground() {
             <div style={{ height: "calc(100vh - 50px)" }}>
               <Editor
                 readonly={false}
-                original={original.current}
+                original={
+                  applyOverlayMode == "original+overlay"
+                    ? original.current
+                    : undefined
+                }
                 value={changed.current}
                 onChange={onChangeBDebounced}
                 loading={changedLoading}
-                title={"Original + Overlay"}
+                title={appliedPanelTitle}
                 index={1}
                 maxOnClick={maxLayout}
               />
@@ -405,6 +448,7 @@ function Playground() {
                 value={result.current}
                 onChange={onChangeCDebounced}
                 loading={resultLoading}
+                markers={overlayMarkers}
                 title={"Overlay"}
                 index={2}
                 maxOnClick={maxLayout}
diff --git a/web/src/assets/wasm/lib.wasm b/web/src/assets/wasm/lib.wasm
index e4ac39d..ff593e3 100755
Binary files a/web/src/assets/wasm/lib.wasm and b/web/src/assets/wasm/lib.wasm differ
diff --git a/web/src/bridge.ts b/web/src/bridge.ts
index cdcc8e3..45123a7 100644
--- a/web/src/bridge.ts
+++ b/web/src/bridge.ts
@@ -98,6 +98,25 @@ export type ApplyOverlayMessage = {
       };
 };
 
+export type QueryJSONPathMessage = {
+  Request: {
+    type: "QueryJSONPath";
+    payload: {
+      source: string;
+      jsonpath: string;
+    };
+  };
+  Response:
+    | {
+        type: "QueryJSONPathResult";
+        payload: string;
+      }
+    | {
+        type: "QueryJSONPathError";
+        error: string;
+      };
+};
+
 export function CalculateOverlay(
   from: string,
   to: string,
@@ -113,18 +132,57 @@ export function CalculateOverlay(
   );
 }
 
-export function ApplyOverlay(
+type IncompleteOverlayErrorMessage = {
+  type: "incomplete";
+  line: number;
+  col: number;
+  result: string;
+};
+
+type JSONPathErrorMessage = {
+  type: "error";
+  line: number;
+  col: number;
+  error: string;
+};
+
+type ApplyOverlayResultMessage = {
+  type: "success";
+  result: string;
+};
+
+type ApplyOverlaySuccess =
+  | ApplyOverlayResultMessage
+  | IncompleteOverlayErrorMessage
+  | JSONPathErrorMessage;
+
+export async function ApplyOverlay(
   source: string,
   overlay: string,
   supercede = false,
-): Promise<string> {
-  return sendMessage(
+): Promise<ApplyOverlaySuccess> {
+  const result = await sendMessage(
     {
       type: "ApplyOverlay",
       payload: { source, overlay },
     } satisfies ApplyOverlayMessage["Request"],
     supercede,
   );
+  return JSON.parse(result);
+}
+
+export function QueryJSONPath(
+  source: string,
+  jsonpath: string,
+  supercede = false,
+): Promise<string> {
+  return sendMessage(
+    {
+      type: "QueryJSONPath",
+      payload: { source, jsonpath },
+    } satisfies QueryJSONPathMessage["Request"],
+    supercede,
+  );
 }
 
 export function GetInfo(openapi: string, supercede = false): Promise<string> {
diff --git a/web/src/components/Editor.tsx b/web/src/components/Editor.tsx
index 9a25e15..00b55a8 100644
--- a/web/src/components/Editor.tsx
+++ b/web/src/components/Editor.tsx
@@ -21,6 +21,7 @@ export interface EditorComponentProps {
   original?: string;
   loading?: boolean;
   title: string;
+  markers?: editor.IMarkerData[];
   index: number;
   maxOnClick?: (index: number) => void;
   onChange: (
@@ -153,6 +154,16 @@ export function Editor(props: EditorComponentProps) {
     }
   }, [isLoading]);
 
+  useEffect(() => {
+    if (modelRef?.current) {
+      monacoRef.current?.editor?.setModelMarkers(
+        modelRef?.current,
+        "diagnostics",
+        props.markers || [],
+      );
+    }
+  }, [props.markers]);
+
   const wrapperStyles = useMemo(() => {
     if (isLoading) {
       return {
diff --git a/web/src/openapi.web.worker.ts b/web/src/openapi.web.worker.ts
index 9e237e2..11fd5f0 100644
--- a/web/src/openapi.web.worker.ts
+++ b/web/src/openapi.web.worker.ts
@@ -5,12 +5,14 @@ import type {
   CalculateOverlayMessage,
   ApplyOverlayMessage,
   GetInfoMessage,
+  QueryJSONPathMessage,
 } from "./bridge";
 
 const _wasmExecutors = {
   CalculateOverlay: (..._: any): any => false,
   ApplyOverlay: (..._: any): any => false,
   GetInfo: (..._: any): any => false,
+  QueryJSONPath: (..._: any): any => false,
 } as const;
 
 type MessageHandlers = {
@@ -29,6 +31,11 @@ const messageHandlers: MessageHandlers = {
   GetInfo: async (payload: GetInfoMessage["Request"]["payload"]) => {
     return exec("GetInfo", payload.openapi);
   },
+  QueryJSONPath: async (
+    payload: QueryJSONPathMessage["Request"]["payload"],
+  ) => {
+    return exec("QueryJSONPath", payload.source, payload.jsonpath);
+  },
 };
 
 let instantiated = false;