Document prompt-owned schemas and finalize migration

This commit is contained in:
2026-11-20 15:46:39 +00:00
parent 9bed36282a
commit e9a12d43c2
16 changed files with 174 additions and 106 deletions

View File

@@ -2,93 +2,73 @@ package jsonvalue
import "reflect"
func cloneTrustedMap(src map[string]any) map[string]any {
if src == nil {
return nil
}
out := make(map[string]any, len(src))
for k, v := range src {
out[k] = CloneTrusted(v)
}
return out
type cloneReference struct {
typeOf reflect.Type
pointer uintptr
length int
}
// CloneTrusted detaches a previously accepted value without revalidating it.
// Cyclic values can also occur in inactive, uninterpreted request fields.
func CloneTrusted(value any) any {
if value == nil {
return nil
}
switch v := value.(type) {
case map[string]any:
return cloneTrustedMap(v)
case []any:
out := make([]any, len(v))
for i, item := range v {
out[i] = CloneTrusted(item)
}
return out
case []string:
if v == nil {
return []string(nil)
}
return append([]string{}, v...)
case []byte:
if v == nil {
return []byte(nil)
}
return append([]byte{}, v...)
default:
return cloneTrustedReflect(reflect.ValueOf(value)).Interface()
}
return cloneTrustedReflect(reflect.ValueOf(value), make(map[cloneReference]reflect.Value)).Interface()
}
func cloneTrustedReflect(value reflect.Value) reflect.Value {
func cloneTrustedReflect(value reflect.Value, active map[cloneReference]reflect.Value) reflect.Value {
if !value.IsValid() {
return value
}
switch value.Kind() {
case reflect.Interface:
if value.IsNil() {
return reflect.Zero(value.Type())
}
copied := cloneTrustedReflect(value.Elem())
if copied.IsValid() && copied.Type().AssignableTo(value.Type()) {
return copied
}
out := reflect.New(value.Type()).Elem()
out.Set(copied)
out.Set(cloneTrustedReflect(value.Elem(), active))
return out
case reflect.Pointer:
case reflect.Pointer, reflect.Map, reflect.Slice:
if value.IsNil() {
return reflect.Zero(value.Type())
}
out := reflect.New(value.Type().Elem())
out.Elem().Set(cloneTrustedReflect(value.Elem()))
return out
case reflect.Map:
if value.IsNil() {
return reflect.Zero(value.Type())
key := cloneReference{typeOf: value.Type(), pointer: uintptr(value.UnsafePointer())}
if value.Kind() == reflect.Slice {
key.length = value.Len()
}
out := reflect.MakeMapWithSize(value.Type(), value.Len())
iter := value.MapRange()
for iter.Next() {
out.SetMapIndex(cloneTrustedReflect(iter.Key()), cloneTrustedReflect(iter.Value()))
if existing, found := active[key]; found {
return existing
}
return out
case reflect.Slice:
if value.IsNil() {
return reflect.Zero(value.Type())
var out reflect.Value
switch value.Kind() {
case reflect.Pointer:
out = reflect.New(value.Type().Elem())
case reflect.Map:
out = reflect.MakeMapWithSize(value.Type(), value.Len())
case reflect.Slice:
out = reflect.MakeSlice(value.Type(), value.Len(), value.Cap())
}
out := reflect.MakeSlice(value.Type(), value.Len(), value.Cap())
for i := 0; i < value.Len(); i++ {
out.Index(i).Set(cloneTrustedReflect(value.Index(i)))
active[key] = out
defer delete(active, key)
switch value.Kind() {
case reflect.Pointer:
out.Elem().Set(cloneTrustedReflect(value.Elem(), active))
case reflect.Map:
iter := value.MapRange()
for iter.Next() {
out.SetMapIndex(cloneTrustedReflect(iter.Key(), active), cloneTrustedReflect(iter.Value(), active))
}
case reflect.Slice:
for i := 0; i < value.Len(); i++ {
out.Index(i).Set(cloneTrustedReflect(value.Index(i), active))
}
}
return out
case reflect.Array:
out := reflect.New(value.Type()).Elem()
for i := 0; i < value.Len(); i++ {
out.Index(i).Set(cloneTrustedReflect(value.Index(i)))
out.Index(i).Set(cloneTrustedReflect(value.Index(i), active))
}
return out
default: