Feat v0.9.2 Starlark converter consolidation + snapshot cleanup (#75)

Consolidate duplicate Go↔Starlark converters into sandbox/convert.go
and snapshot parsers into models/snapshot.go. Standardize snapshot
creation on wrapped format. Net -393 lines across 21 files.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

server/sandbox/convert.go

@@ -0,0 +1,101 @@
+package sandbox
+
+import (
+	"fmt"
+
+	"go.starlark.net/starlark"
+)
+
+// GoToStarlark converts a Go value (typically from JSON unmarshal) to a
+// starlark.Value.  Handles nil, bool, int, int64, float64, string,
+// map[string]any, []any, and their interface{} equivalents.  Unknown
+// types are stringified.
+func GoToStarlark(v any) starlark.Value {
+	switch val := v.(type) {
+	case nil:
+		return starlark.None
+	case bool:
+		return starlark.Bool(val)
+	case int:
+		return starlark.MakeInt(val)
+	case int64:
+		return starlark.MakeInt64(val)
+	case float64:
+		if val == float64(int64(val)) {
+			return starlark.MakeInt64(int64(val))
+		}
+		return starlark.Float(val)
+	case string:
+		return starlark.String(val)
+	case map[string]any:
+		return MapToDict(val)
+	case []any:
+		elems := make([]starlark.Value, len(val))
+		for i, e := range val {
+			elems[i] = GoToStarlark(e)
+		}
+		return starlark.NewList(elems)
+	default:
+		return starlark.String(fmt.Sprintf("%v", val))
+	}
+}
+
+// StarlarkToGo converts a starlark.Value to a Go value suitable for
+// JSON serialization.  Handles None, Bool, Int, Float, String, List,
+// Dict, and Tuple.
+func StarlarkToGo(v starlark.Value) any {
+	switch val := v.(type) {
+	case starlark.NoneType:
+		return nil
+	case starlark.Bool:
+		return bool(val)
+	case starlark.Int:
+		if i, ok := val.Int64(); ok {
+			return i
+		}
+		return val.String()
+	case starlark.Float:
+		return float64(val)
+	case starlark.String:
+		return string(val)
+	case *starlark.List:
+		result := make([]any, val.Len())
+		for i := 0; i < val.Len(); i++ {
+			result[i] = StarlarkToGo(val.Index(i))
+		}
+		return result
+	case *starlark.Dict:
+		return DictToMap(val)
+	case starlark.Tuple:
+		result := make([]any, len(val))
+		for i, e := range val {
+			result[i] = StarlarkToGo(e)
+		}
+		return result
+	default:
+		return v.String()
+	}
+}
+
+// DictToMap converts a *starlark.Dict to map[string]any.
+// Non-string keys are silently skipped.
+func DictToMap(d *starlark.Dict) map[string]any {
+	result := make(map[string]any, d.Len())
+	for _, item := range d.Items() {
+		k, ok := starlark.AsString(item[0])
+		if !ok {
+			continue
+		}
+		result[k] = StarlarkToGo(item[1])
+	}
+	return result
+}
+
+// MapToDict converts a map[string]any to *starlark.Dict.
+func MapToDict(m map[string]any) *starlark.Dict {
+	d := starlark.NewDict(len(m))
+	for k, v := range m {
+		_ = d.SetKey(starlark.String(k), GoToStarlark(v))
+	}
+	return d
+}

server/sandbox/convert_test.go

@@ -0,0 +1,150 @@
+package sandbox
+
+import (
+	"testing"
+
+	"go.starlark.net/starlark"
+)
+
+func TestGoToStarlark_Primitives(t *testing.T) {
+	tests := []struct {
+		name string
+		in   any
+		want string // starlark.Value.String()
+	}{
+		{"nil", nil, "None"},
+		{"bool true", true, "True"},
+		{"bool false", false, "False"},
+		{"int", 42, "42"},
+		{"int64", int64(99), "99"},
+		{"float64 integer", float64(5), "5"},
+		{"float64 fractional", 3.14, "3.14"},
+		{"string", "hello", `"hello"`},
+		{"unknown type", struct{}{}, `"{}"`},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := GoToStarlark(tt.in)
+			if got.String() != tt.want {
+				t.Errorf("GoToStarlark(%v) = %s, want %s", tt.in, got.String(), tt.want)
+			}
+		})
+	}
+}
+
+func TestGoToStarlark_Containers(t *testing.T) {
+	// map[string]any
+	m := map[string]any{"a": 1.0, "b": "two"}
+	d := GoToStarlark(m)
+	if _, ok := d.(*starlark.Dict); !ok {
+		t.Fatalf("expected *starlark.Dict, got %T", d)
+	}
+
+	// []any
+	s := []any{1.0, "x", true}
+	l := GoToStarlark(s)
+	if list, ok := l.(*starlark.List); !ok || list.Len() != 3 {
+		t.Fatalf("expected *starlark.List len 3, got %T", l)
+	}
+
+}
+
+func TestStarlarkToGo_Primitives(t *testing.T) {
+	tests := []struct {
+		name string
+		in   starlark.Value
+		want any
+	}{
+		{"None", starlark.None, nil},
+		{"True", starlark.True, true},
+		{"Int", starlark.MakeInt(7), int64(7)},
+		{"Float", starlark.Float(2.5), 2.5},
+		{"String", starlark.String("hi"), "hi"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := StarlarkToGo(tt.in)
+			if got != tt.want {
+				t.Errorf("StarlarkToGo(%s) = %v (%T), want %v (%T)", tt.in, got, got, tt.want, tt.want)
+			}
+		})
+	}
+}
+
+func TestStarlarkToGo_Tuple(t *testing.T) {
+	tup := starlark.Tuple{starlark.MakeInt(1), starlark.String("a")}
+	got := StarlarkToGo(tup)
+	arr, ok := got.([]any)
+	if !ok || len(arr) != 2 {
+		t.Fatalf("expected []any len 2, got %T", got)
+	}
+	if arr[0] != int64(1) {
+		t.Errorf("arr[0] = %v, want 1", arr[0])
+	}
+}
+
+func TestRoundTrip(t *testing.T) {
+	original := map[string]any{
+		"name":   "test",
+		"count":  float64(42),
+		"active": true,
+		"tags":   []any{"a", "b"},
+		"nested": map[string]any{
+			"x": float64(1),
+		},
+	}
+
+	sv := GoToStarlark(original)
+	back := StarlarkToGo(sv)
+	m, ok := back.(map[string]any)
+	if !ok {
+		t.Fatalf("round-trip produced %T, want map[string]any", back)
+	}
+
+	if m["name"] != "test" {
+		t.Errorf("name = %v", m["name"])
+	}
+	if m["count"] != int64(42) {
+		t.Errorf("count = %v (%T)", m["count"], m["count"])
+	}
+	if m["active"] != true {
+		t.Errorf("active = %v", m["active"])
+	}
+	tags, ok := m["tags"].([]any)
+	if !ok || len(tags) != 2 {
+		t.Fatalf("tags = %v (%T)", m["tags"], m["tags"])
+	}
+	nested, ok := m["nested"].(map[string]any)
+	if !ok {
+		t.Fatalf("nested = %T", m["nested"])
+	}
+	if nested["x"] != int64(1) {
+		t.Errorf("nested.x = %v", nested["x"])
+	}
+}
+
+func TestDictToMap(t *testing.T) {
+	d := starlark.NewDict(2)
+	_ = d.SetKey(starlark.String("k"), starlark.String("v"))
+	_ = d.SetKey(starlark.MakeInt(1), starlark.String("skip")) // non-string key
+
+	m := DictToMap(d)
+	if len(m) != 1 {
+		t.Errorf("expected 1 entry (non-string key skipped), got %d", len(m))
+	}
+	if m["k"] != "v" {
+		t.Errorf("m[k] = %v", m["k"])
+	}
+}
+
+func TestMapToDict(t *testing.T) {
+	m := map[string]any{"a": "b", "n": float64(3)}
+	d := MapToDict(m)
+	if d.Len() != 2 {
+		t.Errorf("expected 2 entries, got %d", d.Len())
+	}
+	v, found, _ := d.Get(starlark.String("a"))
+	if !found || v.(starlark.String) != "b" {
+		t.Errorf("dict[a] = %v", v)
+	}
+}

server/sandbox/files_module.go

@@ -164,7 +164,7 @@ func filesGet(ctx context.Context, cfg FilesModuleConfig) func(*starlark.Thread,
 			metaRC.Close()
 			var m map[string]any
 			if json.Unmarshal(metaBytes, &m) == nil {
-				metaDict = mapToStarlarkDict(m)
+				metaDict = MapToDict(m)
 			}
 		}
 
@@ -207,7 +207,7 @@ func filesMeta(ctx context.Context, cfg FilesModuleConfig) func(*starlark.Thread
 			metaRC.Close()
 			var m map[string]any
 			if json.Unmarshal(metaBytes, &m) == nil {
-				metaDict = mapToStarlarkDict(m)
+				metaDict = MapToDict(m)
 			}
 		}
 
@@ -396,77 +396,13 @@ func filesMaxSize() int64 {
 	return filesDefaultMaxSize
 }
 
-// starlarkDictToMap converts a *starlark.Dict to map[string]any.
+// starlarkDictToMap converts a *starlark.Dict to map[string]any, validating
+// that all keys are strings.  Returns an error if a non-string key is found.
 func starlarkDictToMap(d *starlark.Dict) (map[string]any, error) {
-	m := make(map[string]any, d.Len())
 	for _, item := range d.Items() {
-		k, ok := starlark.AsString(item[0])
-		if !ok {
+		if _, ok := starlark.AsString(item[0]); !ok {
 			return nil, fmt.Errorf("metadata keys must be strings, got %s", item[0].Type())
 		}
-		m[k] = starlarkValueToGo(item[1])
-	}
-	return m, nil
-}
-
-// starlarkValueToGo converts a starlark.Value to a Go value for JSON serialization.
-func starlarkValueToGo(v starlark.Value) any {
-	switch x := v.(type) {
-	case starlark.String:
-		return string(x)
-	case starlark.Int:
-		if i, ok := x.Int64(); ok {
-			return i
-		}
-		return x.String()
-	case starlark.Float:
-		return float64(x)
-	case starlark.Bool:
-		return bool(x)
-	case *starlark.List:
-		out := make([]any, x.Len())
-		for i := 0; i < x.Len(); i++ {
-			out[i] = starlarkValueToGo(x.Index(i))
-		}
-		return out
-	case *starlark.Dict:
-		m, _ := starlarkDictToMap(x)
-		return m
-	default:
-		return v.String()
-	}
-}
-
-// mapToStarlarkDict converts a map[string]any to *starlark.Dict.
-func mapToStarlarkDict(m map[string]any) *starlark.Dict {
-	d := starlark.NewDict(len(m))
-	for k, v := range m {
-		d.SetKey(starlark.String(k), goValueToStarlark(v))
-	}
-	return d
-}
-
-// goValueToStarlark converts a Go value (from JSON) to starlark.Value.
-func goValueToStarlark(v any) starlark.Value {
-	switch x := v.(type) {
-	case string:
-		return starlark.String(x)
-	case float64:
-		if x == float64(int64(x)) {
-			return starlark.MakeInt64(int64(x))
-		}
-		return starlark.Float(x)
-	case bool:
-		return starlark.Bool(x)
-	case []any:
-		elems := make([]starlark.Value, len(x))
-		for i, e := range x {
-			elems[i] = goValueToStarlark(e)
-		}
-		return starlark.NewList(elems)
-	case map[string]any:
-		return mapToStarlarkDict(x)
-	default:
-		return starlark.None
 	}
+	return DictToMap(d), nil
 }

server/sandbox/realtime_module.go

@@ -83,7 +83,7 @@ func realtimePublish(ctx context.Context, bus *events.Bus, packageID string) fun
 				if k == "_pkg" {
 					continue // reserved field
 				}
-				payload[k] = starlarkToGoVal(item[1])
+				payload[k] = StarlarkToGo(item[1])
 			}
 		}
 
@@ -108,46 +108,3 @@ func realtimePublish(ctx context.Context, bus *events.Bus, packageID string) fun
 	}
 }
 
-// starlarkToGoVal converts a Starlark value to a Go value for JSON marshaling.
-func starlarkToGoVal(v starlark.Value) any {
-	switch val := v.(type) {
-	case starlark.NoneType:
-		return nil
-	case starlark.Bool:
-		return bool(val)
-	case starlark.Int:
-		if i, ok := val.Int64(); ok {
-			return i
-		}
-		return val.String()
-	case starlark.Float:
-		return float64(val)
-	case starlark.String:
-		return string(val)
-	case *starlark.Dict:
-		m := make(map[string]any, val.Len())
-		for _, item := range val.Items() {
-			k, ok := starlark.AsString(item[0])
-			if !ok {
-				k = item[0].String()
-			}
-			m[k] = starlarkToGoVal(item[1])
-		}
-		return m
-	case *starlark.List:
-		n := val.Len()
-		s := make([]any, n)
-		for i := 0; i < n; i++ {
-			s[i] = starlarkToGoVal(val.Index(i))
-		}
-		return s
-	case starlark.Tuple:
-		s := make([]any, len(val))
-		for i, v := range val {
-			s[i] = starlarkToGoVal(v)
-		}
-		return s
-	default:
-		return v.String()
-	}
-}

server/sandbox/realtime_module_test.go

@@ -133,7 +133,7 @@ realtime.publish("ch:1", "big.event", {"data": big})
 	}
 }
 
-func TestStarlarkToGoVal(t *testing.T) {
+func TestStarlarkToGo_Realtime(t *testing.T) {
 	tests := []struct {
 		name string
 		val  starlark.Value
@@ -149,9 +149,9 @@ func TestStarlarkToGoVal(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := starlarkToGoVal(tt.val)
+			got := StarlarkToGo(tt.val)
 			if got != tt.want {
-				t.Errorf("starlarkToGoVal(%s) = %v (%T), want %v (%T)", tt.val, got, got, tt.want, tt.want)
+				t.Errorf("StarlarkToGo(%s) = %v (%T), want %v (%T)", tt.val, got, got, tt.want, tt.want)
 			}
 		})
 	}

server/sandbox/workflow_module.go

@@ -112,7 +112,7 @@ func workflowGetInstance(ctx context.Context, stores store.Stores) func(*starlar
 		if json.Unmarshal(inst.StageData, &dataMap) == nil {
 			starlarkData := starlark.NewDict(len(dataMap))
 			for k, v := range dataMap {
-				starlarkData.SetKey(starlark.String(k), goValToStarlark(v))
+				starlarkData.SetKey(starlark.String(k), GoToStarlark(v))
 			}
 			d.SetKey(starlark.String("stage_data"), starlarkData)
 		} else {
@@ -155,36 +155,5 @@ func workflowListInstances(ctx context.Context, stores store.Stores) func(*starl
 	}
 }
 
-// goValToStarlark converts a Go value to a Starlark value.
-func goValToStarlark(v interface{}) starlark.Value {
-	switch val := v.(type) {
-	case nil:
-		return starlark.None
-	case bool:
-		return starlark.Bool(val)
-	case float64:
-		if val == float64(int(val)) {
-			return starlark.MakeInt(int(val))
-		}
-		return starlark.Float(val)
-	case string:
-		return starlark.String(val)
-	case map[string]interface{}:
-		d := starlark.NewDict(len(val))
-		for k, v := range val {
-			d.SetKey(starlark.String(k), goValToStarlark(v))
-		}
-		return d
-	case []interface{}:
-		elems := make([]starlark.Value, len(val))
-		for i, v := range val {
-			elems[i] = goValToStarlark(v)
-		}
-		return starlark.NewList(elems)
-	default:
-		return starlark.String(fmt.Sprintf("%v", v))
-	}
-}
-
 // workflowRoute routes the workflow to a named stage.
 // Starlark: workflow.route(instance_id, target_stage, reason)