Fix race condition while preserving ParentProxy relationships

The previous fix eliminated the race condition by removing ParentProxy
assignment for cached schemas, but broke the parent relationships that
are critical for schema navigation.

This fix creates shallow copies of schemas when returning from cache,
ensuring each SchemaProxy gets its own Schema instance with the correct
ParentProxy set. This eliminates race conditions while maintaining proper
parent relationships and preserving memory efficiency through shallow copying.

- Cache schemas without ParentProxy assignment to avoid races
- Return shallow copies with correct ParentProxy for each caller
- Add comprehensive test for ParentProxy preservation in cached schemas
- All tests pass with race detection enabled

Author: califlower

datamodel/high/base/schema_proxy.go

@@ -116,7 +116,11 @@ func (sp *SchemaProxy) Schema() *Schema {
 			loc := fmt.Sprintf("%s:%d:%d", idx.GetSpecAbsolutePath(), sp.schema.GetValueNode().Line, sp.schema.GetValueNode().Column)
 			if seen, ok := idx.GetHighCache().Load(loc); ok {
 				idx.HighCacheHit()
-				return seen.(*Schema)
+				// Create a copy of the cached schema with the correct ParentProxy
+				cachedSchema := seen.(*Schema)
+				schemaCopy := *cachedSchema // shallow copy
+				schemaCopy.ParentProxy = sp
+				return &schemaCopy
 			} else {
 				idx.HighCacheMiss()
 			}
@@ -144,9 +148,11 @@ func (sp *SchemaProxy) Schema() *Schema {
 		}
 	}
 
-	sch.ParentProxy = sp
-	sp.rendered = sch
-	return sch
+	// Create a copy of the schema to avoid race conditions when setting ParentProxy
+	schemaCopy := *sch // shallow copy
+	schemaCopy.ParentProxy = sp
+	sp.rendered = &schemaCopy
+	return &schemaCopy
 }
 
 // IsReference returns true if the SchemaProxy is a reference to another Schema.

datamodel/high/base/schema_proxy_test.go

@@ -519,3 +519,56 @@ func TestSchemaProxy_ConcurrentCacheAccess(t *testing.T) {
 	}
 	wg.Wait()
 }
+
+func TestSchemaProxy_ParentProxyPreservedForCachedSchemas(t *testing.T) {
+	// Create schema that will be cached
+	const ymlComponents = `components:
+  schemas:
+    TestSchema:
+      type: object
+      properties:
+        name:
+          type: string`
+
+	var idxNode yaml.Node
+	err := yaml.Unmarshal([]byte(ymlComponents), &idxNode)
+	assert.NoError(t, err)
+	idx := index.NewSpecIndexWithConfig(&idxNode, index.CreateOpenAPIIndexConfig())
+
+	// Create first proxy and get schema (this will cache it)
+	const ymlSchema = `$ref: '#/components/schemas/TestSchema'`
+	var node1 yaml.Node
+	yaml.Unmarshal([]byte(ymlSchema), &node1)
+	
+	lowProxy1 := new(lowbase.SchemaProxy)
+	lowProxy1.Build(context.Background(), nil, node1.Content[0], idx)
+	
+	proxy1 := NewSchemaProxy(&low.NodeReference[*lowbase.SchemaProxy]{
+		Value: lowProxy1, ValueNode: node1.Content[0],
+	})
+
+	// Get schema from first proxy (this should cache it)
+	schema1 := proxy1.Schema()
+	assert.NotNil(t, schema1)
+	assert.Equal(t, proxy1, schema1.ParentProxy, "First schema should have correct ParentProxy")
+
+	// Create second proxy for same schema reference
+	var node2 yaml.Node
+	yaml.Unmarshal([]byte(ymlSchema), &node2)
+	
+	lowProxy2 := new(lowbase.SchemaProxy)
+	lowProxy2.Build(context.Background(), nil, node2.Content[0], idx)
+	
+	proxy2 := NewSchemaProxy(&low.NodeReference[*lowbase.SchemaProxy]{
+		Value: lowProxy2, ValueNode: node2.Content[0],
+	})
+
+	// Get schema from second proxy (this should return cached schema)
+	schema2 := proxy2.Schema()
+	assert.NotNil(t, schema2)
+	
+	// CRITICAL TEST: Each proxy should have its own parent relationship
+	// Currently fails due to the race condition fix
+	assert.Equal(t, proxy2, schema2.ParentProxy, "Second schema should have its own ParentProxy, not the first proxy's")
+	assert.NotEqual(t, schema1.ParentProxy, schema2.ParentProxy, "Different proxies should have different parent relationships")
+}