@xrpckit/target-go-server 0.0.2 → 0.0.3

package/dist/index.js

@@ -1,8 +1,18 @@
 // src/generator.ts
-import { BaseCodeGenerator } from "@xrpckit/codegen";
+import {
+  TYPE_KINDS,
+  toPascalCase as toPascalCase7,
+  VALIDATION_KINDS,
+  validateSupport
+} from "@xrpckit/sdk";
+
+// src/server-generator.ts
+import {
+  toPascalCase
+} from "@xrpckit/sdk";
 
 // src/go-builder.ts
-import { CodeWriter } from "@xrpckit/codegen";
+import { CodeWriter } from "@xrpckit/sdk";
 var GoBuilder = class extends CodeWriter {
   // Short aliases
   l(text) {
@@ -78,9 +88,11 @@ var GoBuilder = class extends CodeWriter {
   var(name, type, value) {
     if (type && value) {
       return this.l(`var ${name} ${type} = ${value}`);
-    } else if (type) {
+    }
+    if (type) {
       return this.l(`var ${name} ${type}`);
-    } else if (value) {
+    }
+    if (value) {
       return this.l(`${name} := ${value}`);
     }
     return this.l(`var ${name}`);
@@ -115,63 +127,532 @@ var GoBuilder = class extends CodeWriter {
   }
 };
 
-// src/type-mapper.ts
-import { toPascalCase } from "@xrpckit/codegen";
-var GoTypeMapper = class {
-  mapType(typeRef) {
+// src/server-generator.ts
+function toMethodName(fullName) {
+  return fullName.split(".").map((part) => toPascalCase(part)).join("");
+}
+function toFieldName(fullName) {
+  return fullName.split(".").map((part, i) => i === 0 ? part : toPascalCase(part)).join("");
+}
+var GoServerGenerator = class {
+  w;
+  packageName;
+  constructor(packageName = "server") {
+    this.w = new GoBuilder();
+    this.packageName = packageName;
+  }
+  generateServer(contract) {
+    const w = this.w.reset();
+    w.package(this.packageName).import("encoding/json", "net/http", "fmt");
+    w.struct("Router", (b) => {
+      b.l("middleware []MiddlewareFunc");
+      for (const endpoint of contract.endpoints) {
+        const fieldName = toFieldName(endpoint.fullName);
+        const handlerType = `${toMethodName(endpoint.fullName)}Handler`;
+        b.l(`${fieldName} ${handlerType}`);
+      }
+    });
+    w.func("NewRouter() *Router", (b) => {
+      b.l("return &Router{").i().l("middleware: make([]MiddlewareFunc, 0),").u().l("}");
+    });
+    for (const endpoint of contract.endpoints) {
+      const methodName = toMethodName(endpoint.fullName);
+      const fieldName = toFieldName(endpoint.fullName);
+      const handlerType = `${methodName}Handler`;
+      w.method(
+        "r *Router",
+        methodName,
+        `handler ${handlerType}`,
+        "*Router",
+        (b) => {
+          b.l(`r.${fieldName} = handler`).return("r");
+        }
+      );
+    }
+    w.method(
+      "r *Router",
+      "Use",
+      "middleware MiddlewareFunc",
+      "*Router",
+      (b) => {
+        b.l("r.middleware = append(r.middleware, middleware)").return("r");
+      }
+    );
+    this.generateServeHTTP(contract.endpoints, w);
+    return w.toString();
+  }
+  generateServeHTTP(endpoints, w) {
+    w.method(
+      "r *Router",
+      "ServeHTTP",
+      "w http.ResponseWriter, req *http.Request",
+      "",
+      (b) => {
+        b.if("req.Method != http.MethodPost", (b2) => {
+          b2.l(
+            'http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)'
+          ).return();
+        }).n();
+        b.var("request", "struct {").i().l('Method string          `json:"method"`').l('Params json.RawMessage `json:"params"`').u().l("}").n();
+        b.if(
+          "err := json.NewDecoder(req.Body).Decode(&request); err != nil",
+          (b2) => {
+            b2.l(
+              'http.Error(w, fmt.Sprintf("Invalid request: %v", err), http.StatusBadRequest)'
+            ).return();
+          }
+        ).n();
+        b.decl("ctx", "&Context{").i().l("Request:        req,").l("ResponseWriter: w,").l("Data:           make(map[string]interface{}),").u().l("}").n();
+        b.comment("Execute middleware chain").l("for _, middleware := range r.middleware {").i().decl("result", "middleware(ctx)").if("result.Error != nil", (b2) => {
+          b2.l(
+            'http.Error(w, fmt.Sprintf("Middleware error: %v", result.Error), http.StatusInternalServerError)'
+          ).return();
+        }).if("result.Response != nil", (b2) => {
+          b2.comment("Middleware short-circuited with response").return();
+        }).l("ctx = result.Context").u().l("}").n();
+        const cases = endpoints.map((endpoint) => ({
+          value: `"${endpoint.fullName}"`,
+          fn: (b2) => {
+            const fieldName = toFieldName(endpoint.fullName);
+            b2.if(`r.${fieldName} == nil`, (b3) => {
+              b3.l(
+                'http.Error(w, "Handler not registered", http.StatusNotFound)'
+              ).return();
+            }).n();
+            const inputTypeName = toPascalCase(endpoint.input.name);
+            b2.var("input", inputTypeName);
+            b2.if(
+              "err := json.Unmarshal(request.Params, &input); err != nil",
+              (b3) => {
+                b3.l(
+                  'http.Error(w, fmt.Sprintf("Invalid params: %v", err), http.StatusBadRequest)'
+                ).return();
+              }
+            ).n();
+            const validationFuncName = `Validate${inputTypeName}`;
+            b2.if(`err := ${validationFuncName}(input); err != nil`, (b3) => {
+              b3.l('w.Header().Set("Content-Type", "application/json")').l(
+                "w.WriteHeader(http.StatusBadRequest)"
+              );
+              b3.l("if validationErrs, ok := err.(ValidationErrors); ok {").i().l("json.NewEncoder(w).Encode(map[string]interface{}{").i().l('"error": "Validation failed",').l('"errors": validationErrs,').u().l("})").u().l("} else {").i().l("json.NewEncoder(w).Encode(map[string]interface{}{").i().l('"error": err.Error(),').u().l("})").u().l("}");
+              b3.return();
+            }).n();
+            b2.decl("result, err", `r.${fieldName}(ctx, input)`);
+            b2.ifErr((b3) => {
+              b3.l('w.Header().Set("Content-Type", "application/json")').l(
+                'json.NewEncoder(w).Encode(map[string]interface{}{"error": err.Error()})'
+              ).return();
+            }).n();
+            b2.l('w.Header().Set("Content-Type", "application/json")').l(
+              'json.NewEncoder(w).Encode(map[string]interface{}{"result": result})'
+            ).return();
+          }
+        }));
+        w.switch("request.Method", cases, (b2) => {
+          b2.l(
+            'http.Error(w, "Method not found", http.StatusNotFound)'
+          ).return();
+        });
+      }
+    );
+  }
+};
+
+// src/type-collector.ts
+import {
+  toPascalCase as toPascalCase2
+} from "@xrpckit/sdk";
+var GoTypeCollector = class {
+  collectedTypes = /* @__PURE__ */ new Map();
+  usedNames = /* @__PURE__ */ new Set();
+  /**
+   * Collect all types from a contract that need Go struct generation.
+   * This includes:
+   * - Named types from contract.types
+   * - Anonymous inline objects nested in properties
+   * - Array element types that are inline objects
+   * - Optional/nullable wrapped inline objects
+   */
+  collectTypes(contract) {
+    this.collectedTypes.clear();
+    this.usedNames.clear();
+    for (const type of contract.types) {
+      const pascalName = toPascalCase2(type.name);
+      this.usedNames.add(pascalName);
+    }
+    for (const type of contract.types) {
+      this.processTypeDefinition(type, type.name);
+    }
+    return Array.from(this.collectedTypes.values());
+  }
+  /**
+   * Process a type definition and extract any nested inline types
+   */
+  processTypeDefinition(type, contextName) {
+    if (type.properties) {
+      for (const prop of type.properties) {
+        this.processProperty(prop, contextName);
+      }
+    }
+    if (type.kind === "array" && type.elementType) {
+      this.processTypeReference(
+        type.elementType,
+        `${contextName}Item`,
+        `${contextName}.elementType`
+      );
+    }
+  }
+  /**
+   * Process a property and extract any nested inline types
+   */
+  processProperty(prop, parentContext) {
+    const propContext = `${parentContext}${toPascalCase2(prop.name)}`;
+    this.processTypeReference(
+      prop.type,
+      propContext,
+      `${parentContext}.${prop.name}`
+    );
+  }
+  /**
+   * Process a type reference and extract any nested inline types.
+   * This is the core function that handles all the different type kinds.
+   */
+  processTypeReference(typeRef, suggestedName, source) {
     if (typeRef.kind === "optional") {
       if (typeof typeRef.baseType === "object") {
-        return this.mapType(typeRef.baseType);
+        this.processTypeReference(
+          typeRef.baseType,
+          suggestedName,
+          `${source}.optional`
+        );
       }
-      return "interface{}";
+      return;
     }
     if (typeRef.kind === "nullable") {
       if (typeof typeRef.baseType === "object") {
-        return `*${this.mapType(typeRef.baseType)}`;
+        this.processTypeReference(
+          typeRef.baseType,
+          suggestedName,
+          `${source}.nullable`
+        );
       }
-      return "*interface{}";
+      return;
     }
-    if (typeRef.kind === "array") {
-      return `[]${this.mapType(typeRef.elementType)}`;
+    if (typeRef.kind === "array" && typeRef.elementType) {
+      const elementName = suggestedName.endsWith("Item") ? suggestedName : `${suggestedName}Item`;
+      this.processTypeReference(
+        typeRef.elementType,
+        elementName,
+        `${source}.array`
+      );
+      return;
     }
-    if (typeRef.kind === "object") {
-      if (typeRef.name) {
-        return toPascalCase(typeRef.name);
+    if (typeRef.kind === "object" && typeRef.properties && !typeRef.name) {
+      const assignedName = this.assignUniqueName(suggestedName);
+      typeRef.name = assignedName;
+      this.collectedTypes.set(assignedName, {
+        name: assignedName,
+        typeRef,
+        source
+      });
+      for (const prop of typeRef.properties) {
+        this.processProperty(prop, assignedName);
       }
-      return "interface{}";
-    }
-    if (typeRef.kind === "record") {
-      const valueType = typeRef.valueType ? this.mapType(typeRef.valueType) : "interface{}";
-      return `map[string]${valueType}`;
+      return;
     }
-    if (typeRef.kind === "tuple") {
-      return "[]interface{}";
+    if (typeRef.kind === "record" && typeRef.valueType) {
+      this.processTypeReference(
+        typeRef.valueType,
+        `${suggestedName}Value`,
+        `${source}.record`
+      );
+      return;
     }
-    if (typeRef.kind === "union") {
-      return "interface{}";
+    if (typeRef.kind === "tuple" && typeRef.tupleElements) {
+      typeRef.tupleElements.forEach((elem, index) => {
+        this.processTypeReference(
+          elem,
+          `${suggestedName}V${index}`,
+          `${source}.tuple[${index}]`
+        );
+      });
+      return;
     }
-    if (typeRef.kind === "enum") {
-      return "string";
+    if (typeRef.kind === "union" && typeRef.unionTypes) {
+      typeRef.unionTypes.forEach((variant, index) => {
+        this.processTypeReference(
+          variant,
+          `${suggestedName}Variant${index}`,
+          `${source}.union[${index}]`
+        );
+      });
+      return;
     }
-    if (typeRef.kind === "literal") {
-      if (typeof typeRef.literalValue === "string") {
-        return "string";
-      } else if (typeof typeRef.literalValue === "number") {
-        return "float64";
-      } else if (typeof typeRef.literalValue === "boolean") {
-        return "bool";
+    if (typeRef.kind === "object" && typeRef.properties && typeRef.name) {
+      for (const prop of typeRef.properties) {
+        this.processProperty(prop, toPascalCase2(typeRef.name));
       }
-      return "interface{}";
-    }
-    if (typeRef.kind === "date") {
-      return "time.Time";
     }
-    if (typeRef.kind === "primitive") {
-      const baseType = typeof typeRef.baseType === "string" ? typeRef.baseType : "unknown";
-      return this.mapPrimitive(baseType);
+  }
+  /**
+   * Assign a unique name, adding numeric suffix if there's a collision
+   */
+  assignUniqueName(baseName) {
+    let name = baseName;
+    let counter = 1;
+    while (this.usedNames.has(name)) {
+      name = `${baseName}${counter}`;
+      counter++;
     }
-    return "interface{}";
+    this.usedNames.add(name);
+    return name;
+  }
+  /**
+   * Get all collected nested types (not including the main contract types)
+   */
+  getCollectedTypes() {
+    return Array.from(this.collectedTypes.values());
   }
+};
+
+// src/type-generator.ts
+import {
+  toPascalCase as toPascalCase5
+} from "@xrpckit/sdk";
+
+// src/type-mapper.ts
+import {
+  TypeMapperBase,
+  toPascalCase as toPascalCase4
+} from "@xrpckit/sdk";
+
+// src/patterns.ts
+import { toPascalCase as toPascalCase3 } from "@xrpckit/sdk";
+function createGoEnumPattern(name, values) {
+  const stringValues = values.filter((v) => typeof v === "string");
+  const constants = stringValues.map((v) => {
+    const constName = `${name}${toPascalCase3(v)}`;
+    return { constName, value: v };
+  });
+  const code = `// ${name} enum type
+type ${name} string
+
+const (
+${constants.map((c) => `	${c.constName} ${name} = "${c.value}"`).join("\n")}
+)
+
+// IsValid checks if the ${name} value is valid
+func (e ${name}) IsValid() bool {
+	switch e {
+	case ${constants.map((c) => c.constName).join(", ")}:
+		return true
+	}
+	return false
+}
+
+// Parse${name} parses a string into a ${name} value
+func Parse${name}(s string) (${name}, error) {
+	e := ${name}(s)
+	if !e.IsValid() {
+		return "", fmt.Errorf("invalid ${name}: %s", s)
+	}
+	return e, nil
+}
+
+// All${name}Values returns all valid ${name} values
+func All${name}Values() []${name} {
+	return []${name}{${constants.map((c) => c.constName).join(", ")}}
+}`;
+  return {
+    id: `enum_${name}`,
+    code,
+    imports: ["fmt"],
+    includeOnce: true,
+    priority: 100
+    // Enums should come early
+  };
+}
+function createGoBigIntPattern() {
+  const code = `// BigInt is a wrapper around big.Int for JSON serialization
+type BigInt struct {
+	*big.Int
+}
+
+// MarshalJSON implements json.Marshaler for BigInt
+func (b BigInt) MarshalJSON() ([]byte, error) {
+	if b.Int == nil {
+		return []byte("null"), nil
+	}
+	return []byte(b.String()), nil
+}
+
+// UnmarshalJSON implements json.Unmarshaler for BigInt
+func (b *BigInt) UnmarshalJSON(data []byte) error {
+	str := string(data)
+	if str == "null" {
+		b.Int = nil
+		return nil
+	}
+	// Remove quotes if present
+	if len(str) >= 2 && str[0] == '"' && str[len(str)-1] == '"' {
+		str = str[1 : len(str)-1]
+	}
+	b.Int = new(big.Int)
+	_, ok := b.Int.SetString(str, 10)
+	if !ok {
+		return fmt.Errorf("invalid BigInt: %s", str)
+	}
+	return nil
+}`;
+  return {
+    id: "bigint",
+    code,
+    imports: ["math/big", "fmt"],
+    includeOnce: true,
+    priority: 90
+  };
+}
+function createGoUnionPattern(name, variants) {
+  const assertions = variants.map((v) => {
+    const methodName = `As${toPascalCase3(v.replace(/[*[\]]/g, ""))}`;
+    return `// ${methodName} returns the value as ${v}, or ok=false if not that type
+func (u ${name}) ${methodName}() (${v}, bool) {
+	val, ok := u.Value.(${v})
+	return val, ok
+}`;
+  }).join("\n\n");
+  const code = `// ${name} represents a union type that can hold one of several types
+type ${name} struct {
+	Value interface{}
+}
+
+// MarshalJSON implements json.Marshaler for ${name}
+func (u ${name}) MarshalJSON() ([]byte, error) {
+	return json.Marshal(u.Value)
+}
+
+// UnmarshalJSON implements json.Unmarshaler for ${name}
+func (u *${name}) UnmarshalJSON(data []byte) error {
+	return json.Unmarshal(data, &u.Value)
+}
+
+${assertions}`;
+  return {
+    id: `union_${name}`,
+    code,
+    imports: ["encoding/json"],
+    includeOnce: true,
+    priority: 80
+  };
+}
+function createGoTuplePattern(name, elements) {
+  const fields = elements.map((el, i) => `	V${i} ${el} \`json:"${i}"\``);
+  const code = `// ${name} represents a tuple type with ${elements.length} elements
+type ${name} struct {
+${fields.join("\n")}
+}
+
+// MarshalJSON implements json.Marshaler for ${name} to serialize as JSON array
+func (t ${name}) MarshalJSON() ([]byte, error) {
+	return json.Marshal([]interface{}{${elements.map((_, i) => `t.V${i}`).join(", ")}})
+}
+
+// UnmarshalJSON implements json.Unmarshaler for ${name} from JSON array
+func (t *${name}) UnmarshalJSON(data []byte) error {
+	var arr []json.RawMessage
+	if err := json.Unmarshal(data, &arr); err != nil {
+		return err
+	}
+	if len(arr) != ${elements.length} {
+		return fmt.Errorf("expected ${elements.length} elements, got %d", len(arr))
+	}
+${elements.map((_, i) => `	if err := json.Unmarshal(arr[${i}], &t.V${i}); err != nil {
+		return fmt.Errorf("element ${i}: %w", err)
+	}`).join("\n")}
+	return nil
+}`;
+  return {
+    id: `tuple_${name}`,
+    code,
+    imports: ["encoding/json", "fmt"],
+    includeOnce: true,
+    priority: 70
+  };
+}
+function createGoDatePattern() {
+  const code = `// DateTime is a wrapper around time.Time with flexible JSON parsing
+type DateTime struct {
+	time.Time
+}
+
+// Common date/time formats to try when parsing
+var dateTimeFormats = []string{
+	time.RFC3339,
+	time.RFC3339Nano,
+	"2006-01-02T15:04:05Z07:00",
+	"2006-01-02T15:04:05",
+	"2006-01-02",
+}
+
+// UnmarshalJSON implements json.Unmarshaler for DateTime
+func (d *DateTime) UnmarshalJSON(data []byte) error {
+	str := string(data)
+	if str == "null" {
+		return nil
+	}
+	// Remove quotes
+	if len(str) >= 2 && str[0] == '"' && str[len(str)-1] == '"' {
+		str = str[1 : len(str)-1]
+	}
+	// Try each format
+	for _, format := range dateTimeFormats {
+		if t, err := time.Parse(format, str); err == nil {
+			d.Time = t
+			return nil
+		}
+	}
+	return fmt.Errorf("cannot parse date: %s", str)
+}
+
+// MarshalJSON implements json.Marshaler for DateTime
+func (d DateTime) MarshalJSON() ([]byte, error) {
+	return json.Marshal(d.Time.Format(time.RFC3339))
+}`;
+  return {
+    id: "datetime",
+    code,
+    imports: ["time", "encoding/json", "fmt"],
+    includeOnce: true,
+    priority: 85
+  };
+}
+
+// src/type-mapper.ts
+var GoTypeMapper = class extends TypeMapperBase {
+  // Registry of tuple type names for reference during validation
+  tupleTypes = /* @__PURE__ */ new Map();
+  // Registry of union type names
+  unionTypes = /* @__PURE__ */ new Map();
+  /**
+   * Complete mapping of all type kinds to Go types.
+   * TypeScript enforces exhaustiveness at compile time.
+   */
+  typeMapping = {
+    object: (ctx) => this.handleObject(ctx),
+    array: (ctx) => this.handleArray(ctx),
+    primitive: (ctx) => this.handlePrimitive(ctx),
+    optional: (ctx) => this.handleOptional(ctx),
+    nullable: (ctx) => this.handleNullable(ctx),
+    union: (ctx) => this.handleUnion(ctx),
+    enum: (ctx) => this.handleEnum(ctx),
+    literal: (ctx) => this.handleLiteral(ctx),
+    record: (ctx) => this.handleRecord(ctx),
+    tuple: (ctx) => this.handleTuple(ctx),
+    date: () => this.handleDate()
+  };
+  /**
+   * Map a primitive base type to Go type.
+   */
   mapPrimitive(type) {
     const mapping = {
       string: "string",
@@ -180,34 +661,240 @@ var GoTypeMapper = class {
       boolean: "bool",
       date: "time.Time",
       uuid: "string",
-      email: "string"
+      email: "string",
+      any: "interface{}",
+      unknown: "interface{}"
+    };
+    const result = mapping[type];
+    if (!result) {
+      console.warn("[GoTypeMapper] Unknown primitive type:", type);
+      return "interface{}";
+    }
+    return result;
+  }
+  /**
+   * Get all registered tuple types that need struct generation
+   */
+  getTupleTypes() {
+    return this.tupleTypes;
+  }
+  /**
+   * Get all registered union types that need wrapper struct generation
+   */
+  getUnionTypes() {
+    return this.unionTypes;
+  }
+  /**
+   * Reset the type registries (call between generation runs)
+   */
+  reset() {
+    super.reset();
+    this.tupleTypes.clear();
+    this.unionTypes.clear();
+  }
+  // --- Private handler methods ---
+  handleObject(ctx) {
+    const { typeRef, name } = ctx;
+    if (name || typeRef.name) {
+      return { type: toPascalCase4(name || typeRef.name) };
+    }
+    console.warn(
+      "[GoTypeMapper] Object without name - falling back to map[string]interface{}:",
+      typeRef
+    );
+    return { type: "map[string]interface{}" };
+  }
+  handleArray(ctx) {
+    const { typeRef } = ctx;
+    if (!typeRef.elementType) {
+      return { type: "[]interface{}" };
+    }
+    const element = this.mapType(typeRef.elementType);
+    return {
+      type: `[]${element.type}`,
+      imports: element.imports
+    };
+  }
+  handlePrimitive(ctx) {
+    const { typeRef } = ctx;
+    const baseType = typeof typeRef.baseType === "string" ? typeRef.baseType : "unknown";
+    const goType = this.mapPrimitive(baseType);
+    if (goType === "time.Time") {
+      return { type: goType, imports: ["time"] };
+    }
+    return { type: goType };
+  }
+  handleOptional(ctx) {
+    const { typeRef } = ctx;
+    if (typeof typeRef.baseType === "object") {
+      return this.mapType(typeRef.baseType);
+    }
+    if (typeof typeRef.baseType === "string") {
+      return { type: this.mapPrimitive(typeRef.baseType) };
+    }
+    console.warn("[GoTypeMapper] Optional with unknown baseType:", typeRef);
+    return { type: "interface{}" };
+  }
+  handleNullable(ctx) {
+    const { typeRef } = ctx;
+    if (typeof typeRef.baseType === "object") {
+      const base = this.mapType(typeRef.baseType);
+      return {
+        type: `*${base.type}`,
+        imports: base.imports
+      };
+    }
+    if (typeof typeRef.baseType === "string") {
+      return { type: `*${this.mapPrimitive(typeRef.baseType)}` };
+    }
+    console.warn("[GoTypeMapper] Nullable with unknown baseType:", typeRef);
+    return { type: "*interface{}" };
+  }
+  handleUnion(ctx) {
+    const { typeRef, name } = ctx;
+    const unionName = name || typeRef.name;
+    if (unionName) {
+      const goName = toPascalCase4(unionName);
+      this.unionTypes.set(goName, typeRef);
+      const variants = typeRef.unionTypes?.map((v) => this.mapType(v).type) ?? [];
+      const utility = createGoUnionPattern(goName, variants);
+      return {
+        type: goName,
+        utilities: [utility],
+        imports: utility.imports
+      };
+    }
+    if (typeRef.unionTypes && typeRef.unionTypes.length > 0) {
+      const variantTypes = typeRef.unionTypes.map((v) => this.mapType(v));
+      const allSameType = variantTypes.every(
+        (v) => v.type === variantTypes[0].type
+      );
+      if (allSameType) {
+        return variantTypes[0];
+      }
+      const nonNullVariants = typeRef.unionTypes.filter(
+        (v) => !(v.kind === "literal" && v.literalValue === null)
+      );
+      if (nonNullVariants.length === 1) {
+        const base = this.mapType(nonNullVariants[0]);
+        return {
+          type: `*${base.type}`,
+          imports: base.imports
+        };
+      }
+    }
+    console.warn(
+      "[GoTypeMapper] Anonymous heterogeneous union - using interface{}:",
+      typeRef
+    );
+    return { type: "interface{}" };
+  }
+  handleEnum(_ctx) {
+    return { type: "string" };
+  }
+  handleLiteral(ctx) {
+    const { typeRef } = ctx;
+    if (typeRef.literalValue === null) {
+      return { type: "interface{}" };
+    }
+    if (typeof typeRef.literalValue === "string") {
+      return { type: "string" };
+    }
+    if (typeof typeRef.literalValue === "number") {
+      return { type: "float64" };
+    }
+    if (typeof typeRef.literalValue === "boolean") {
+      return { type: "bool" };
+    }
+    console.warn("[GoTypeMapper] Unknown literal type:", typeRef);
+    return { type: "interface{}" };
+  }
+  handleRecord(ctx) {
+    const { typeRef } = ctx;
+    if (!typeRef.valueType) {
+      return { type: "map[string]interface{}" };
+    }
+    const value = this.mapType(typeRef.valueType);
+    return {
+      type: `map[string]${value.type}`,
+      imports: value.imports
+    };
+  }
+  handleTuple(ctx) {
+    const { typeRef, name } = ctx;
+    const tupleName = name || typeRef.name;
+    if (tupleName) {
+      const goName = toPascalCase4(tupleName);
+      this.tupleTypes.set(goName, typeRef);
+      const elements = typeRef.tupleElements?.map((e) => this.mapType(e).type) ?? [];
+      const utility = createGoTuplePattern(goName, elements);
+      return {
+        type: goName,
+        utilities: [utility],
+        imports: utility.imports
+      };
+    }
+    if (typeRef.tupleElements && typeRef.tupleElements.length > 0) {
+      const elementTypes = typeRef.tupleElements.map((e) => this.mapType(e));
+      const allSameType = elementTypes.every(
+        (e) => e.type === elementTypes[0].type
+      );
+      if (allSameType) {
+        return { type: `[]${elementTypes[0].type}` };
+      }
+    }
+    console.warn(
+      "[GoTypeMapper] Anonymous heterogeneous tuple - using []interface{}:",
+      typeRef
+    );
+    return { type: "[]interface{}" };
+  }
+  handleDate() {
+    return {
+      type: "time.Time",
+      imports: ["time"]
     };
-    return mapping[type] || "interface{}";
   }
 };
 
 // src/type-generator.ts
-import { toPascalCase as toPascalCase2 } from "@xrpckit/codegen";
-function toMethodName(fullName) {
-  return fullName.split(".").map((part) => toPascalCase2(part)).join("");
+function toMethodName2(fullName) {
+  return fullName.split(".").map((part) => toPascalCase5(part)).join("");
 }
 var GoTypeGenerator = class {
   w;
   typeMapper;
   packageName;
+  generatedTypes = /* @__PURE__ */ new Set();
   constructor(packageName = "server") {
     this.w = new GoBuilder();
     this.typeMapper = new GoTypeMapper();
     this.packageName = packageName;
   }
-  generateTypes(contract) {
+  /**
+   * Generate Go types from a contract definition.
+   * @param contract - The contract definition (should have names assigned to inline types)
+   * @param collectedTypes - Optional pre-collected nested types from GoTypeCollector
+   */
+  generateTypes(contract, collectedTypes) {
     const w = this.w.reset();
+    this.typeMapper.reset();
+    this.generatedTypes.clear();
     w.package(this.packageName).import("net/http");
     this.generateContextType();
     this.generateMiddlewareTypes();
     for (const type of contract.types) {
       this.generateType(type);
     }
+    if (collectedTypes) {
+      for (const collected of collectedTypes) {
+        if (!this.generatedTypes.has(collected.name)) {
+          this.generateTypeFromReference(collected.name, collected.typeRef);
+        }
+      }
+    }
+    this.generateTupleTypes();
+    this.generateUnionTypes();
     this.generateTypedHandlers(contract);
     return w.toString();
   }
@@ -215,21 +902,11 @@ var GoTypeGenerator = class {
     this.w.struct("Context", (b) => {
       b.l("Request        *http.Request").l("ResponseWriter http.ResponseWriter").l("Data           map[string]interface{}");
     }).n();
-    this.w.comment("GetUserId retrieves userId from context if set by middleware").n().func("GetUserId(ctx *Context) (string, bool)", (b) => {
-      b.if('val, ok := ctx.Data["userId"].(string); ok', (b2) => {
-        b2.return("val, true");
-      });
-      b.return('"", false');
-    }).n();
-    this.w.comment("GetSessionId retrieves sessionId from context if set by middleware").n().func("GetSessionId(ctx *Context) (string, bool)", (b) => {
-      b.if('val, ok := ctx.Data["sessionId"].(string); ok', (b2) => {
-        b2.return("val, true");
-      });
-      b.return('"", false');
-    }).n();
   }
   generateMiddlewareTypes() {
-    this.w.comment("MiddlewareFunc is a function that processes a request and extends context").n().type("MiddlewareFunc", "func(ctx *Context) *MiddlewareResult").n();
+    this.w.comment(
+      "MiddlewareFunc is a function that processes a request and extends context"
+    ).n().type("MiddlewareFunc", "func(ctx *Context) *MiddlewareResult").n();
     this.w.struct("MiddlewareResult", (b) => {
       b.l("Context  *Context").l("Error    error").l("Response *http.Response");
     }).n();
@@ -239,38 +916,157 @@ var GoTypeGenerator = class {
     this.w.comment("NewMiddlewareError creates a middleware result with an error").n().func("NewMiddlewareError(err error) *MiddlewareResult", (b) => {
       b.return("&MiddlewareResult{Error: err}");
     }).n();
-    this.w.comment("NewMiddlewareResponse creates a middleware result that short-circuits with a response").n().func("NewMiddlewareResponse(resp *http.Response) *MiddlewareResult", (b) => {
-      b.return("&MiddlewareResult{Response: resp}");
-    }).n();
+    this.w.comment(
+      "NewMiddlewareResponse creates a middleware result that short-circuits with a response"
+    ).n().func(
+      "NewMiddlewareResponse(resp *http.Response) *MiddlewareResult",
+      (b) => {
+        b.return("&MiddlewareResult{Response: resp}");
+      }
+    ).n();
   }
   generateType(type) {
-    const typeName = toPascalCase2(type.name);
+    const typeName = toPascalCase5(type.name);
+    if (this.generatedTypes.has(typeName)) {
+      return;
+    }
     if (type.kind === "array" && type.elementType) {
       if (type.elementType.kind === "object" && type.elementType.properties) {
-        const elementTypeName = typeName + "Item";
-        this.w.struct(elementTypeName, (b) => {
-          for (const prop of type.elementType.properties) {
-            const goType = this.typeMapper.mapType(prop.type);
-            const jsonTag = this.generateJSONTag(prop);
-            b.l(`${toPascalCase2(prop.name)} ${goType} \`${jsonTag}\``);
-          }
-        });
+        const elementTypeName = type.elementType.name ? toPascalCase5(type.elementType.name) : `${typeName}Item`;
+        if (!this.generatedTypes.has(elementTypeName)) {
+          this.generateTypeFromReference(elementTypeName, type.elementType);
+        }
+        this.generatedTypes.add(typeName);
         this.w.type(typeName, `[]${elementTypeName}`);
       } else {
-        const elementGoType = this.typeMapper.mapType(type.elementType);
+        const elementGoType = this.typeMapper.mapType(type.elementType).type;
+        this.generatedTypes.add(typeName);
         this.w.type(typeName, `[]${elementGoType}`);
       }
       return;
     }
-    this.w.struct(typeName, (b) => {
-      if (type.properties) {
-        for (const prop of type.properties) {
-          const goType = this.typeMapper.mapType(prop.type);
+    if (type.kind === "object") {
+      this.generatedTypes.add(typeName);
+      this.w.struct(typeName, (b) => {
+        if (type.properties) {
+          for (const prop of type.properties) {
+            const goType2 = this.typeMapper.mapType(prop.type).type;
+            const jsonTag = this.generateJSONTag(prop);
+            b.l(`${toPascalCase5(prop.name)} ${goType2} \`${jsonTag}\``);
+          }
+        }
+      });
+      return;
+    }
+    if (type.kind === "union" || type.kind === "tuple") {
+      this.typeMapper.mapType(type);
+      return;
+    }
+    const goType = this.typeMapper.mapType(type).type;
+    this.generatedTypes.add(typeName);
+    this.w.type(typeName, goType);
+  }
+  /**
+   * Generate a type from a TypeReference (used for nested inline types)
+   */
+  generateTypeFromReference(typeName, typeRef) {
+    if (this.generatedTypes.has(typeName)) {
+      return;
+    }
+    if (typeRef.kind === "object" && typeRef.properties) {
+      this.generatedTypes.add(typeName);
+      this.w.struct(typeName, (b) => {
+        for (const prop of typeRef.properties) {
+          const goType2 = this.typeMapper.mapType(prop.type).type;
           const jsonTag = this.generateJSONTag(prop);
-          b.l(`${toPascalCase2(prop.name)} ${goType} \`${jsonTag}\``);
+          b.l(`${toPascalCase5(prop.name)} ${goType2} \`${jsonTag}\``);
         }
+      });
+      return;
+    }
+    if (typeRef.kind === "array" && typeRef.elementType) {
+      if (typeRef.elementType.kind === "object" && typeRef.elementType.properties) {
+        const elementTypeName = typeRef.elementType.name ? toPascalCase5(typeRef.elementType.name) : `${typeName}Item`;
+        if (!this.generatedTypes.has(elementTypeName)) {
+          this.generateTypeFromReference(elementTypeName, typeRef.elementType);
+        }
+        this.generatedTypes.add(typeName);
+        this.w.type(typeName, `[]${elementTypeName}`);
+      } else {
+        const elementGoType = this.typeMapper.mapType(typeRef.elementType).type;
+        this.generatedTypes.add(typeName);
+        this.w.type(typeName, `[]${elementGoType}`);
       }
-    });
+      return;
+    }
+    if (typeRef.kind === "union" || typeRef.kind === "tuple") {
+      this.typeMapper.mapType(typeRef, { name: typeName });
+      return;
+    }
+    const goType = this.typeMapper.mapType(typeRef).type;
+    this.generatedTypes.add(typeName);
+    this.w.type(typeName, goType);
+  }
+  /**
+   * Generate struct types for tuples
+   */
+  generateTupleTypes() {
+    const tupleTypes = this.typeMapper.getTupleTypes();
+    for (const [name, typeRef] of tupleTypes) {
+      if (this.generatedTypes.has(name)) continue;
+      this.generatedTypes.add(name);
+      if (typeRef.tupleElements && typeRef.tupleElements.length > 0) {
+        this.w.struct(name, (b) => {
+          typeRef.tupleElements?.forEach((elem, index) => {
+            const goType = this.typeMapper.mapType(elem).type;
+            b.l(`V${index} ${goType} \`json:"v${index}"\``);
+          });
+        });
+      }
+    }
+  }
+  /**
+   * Generate wrapper struct types for unions
+   */
+  generateUnionTypes() {
+    const unionTypes = this.typeMapper.getUnionTypes();
+    for (const [name, typeRef] of unionTypes) {
+      if (this.generatedTypes.has(name)) continue;
+      this.generatedTypes.add(name);
+      if (typeRef.unionTypes && typeRef.unionTypes.length > 0) {
+        this.w.struct(name, (b) => {
+          b.l('Type string `json:"type,omitempty"`');
+          const seenTypes = /* @__PURE__ */ new Set();
+          typeRef.unionTypes?.forEach((variant, index) => {
+            const goType = this.typeMapper.mapType(variant).type;
+            if (seenTypes.has(goType)) return;
+            seenTypes.add(goType);
+            const fieldName = this.getUnionFieldName(variant, index);
+            b.l(
+              `${fieldName} *${goType} \`json:"${fieldName.toLowerCase()},omitempty"\``
+            );
+          });
+        });
+      }
+    }
+  }
+  /**
+   * Get a descriptive field name for a union variant
+   */
+  getUnionFieldName(typeRef, index) {
+    if (typeRef.name) {
+      return toPascalCase5(typeRef.name);
+    }
+    if (typeRef.kind === "primitive" && typeof typeRef.baseType === "string") {
+      return toPascalCase5(typeRef.baseType);
+    }
+    if (typeRef.kind === "literal") {
+      const val = typeRef.literalValue;
+      if (typeof val === "string") return `String${index}`;
+      if (typeof val === "number") return `Number${index}`;
+      if (typeof val === "boolean") return `Bool${index}`;
+    }
+    return `Variant${index}`;
   }
   generateJSONTag(prop) {
     if (prop.required) {
@@ -281,128 +1077,53 @@ var GoTypeGenerator = class {
   generateTypedHandlers(contract) {
     this.w.comment("Typed handler types for each endpoint").n();
     for (const endpoint of contract.endpoints) {
-      const handlerName = toMethodName(endpoint.fullName) + "Handler";
-      const inputType = toPascalCase2(endpoint.input.name);
-      const outputType = toPascalCase2(endpoint.output.name);
-      this.w.comment(`Handler type for ${endpoint.fullName}`).type(handlerName, `func(ctx *Context, input ${inputType}) (${outputType}, error)`).n();
-    }
-  }
-};
-
-// src/server-generator.ts
-import { toPascalCase as toPascalCase3 } from "@xrpckit/codegen";
-function toMethodName2(fullName) {
-  return fullName.split(".").map((part) => toPascalCase3(part)).join("");
-}
-function toFieldName(fullName) {
-  return fullName.split(".").map((part, i) => i === 0 ? part : toPascalCase3(part)).join("");
-}
-var GoServerGenerator = class {
-  w;
-  packageName;
-  constructor(packageName = "server") {
-    this.w = new GoBuilder();
-    this.packageName = packageName;
-  }
-  generateServer(contract) {
-    const w = this.w.reset();
-    w.package(this.packageName).import("encoding/json", "net/http", "fmt");
-    w.struct("Router", (b) => {
-      b.l("middleware []MiddlewareFunc");
-      for (const endpoint of contract.endpoints) {
-        const fieldName = toFieldName(endpoint.fullName);
-        const handlerType = toMethodName2(endpoint.fullName) + "Handler";
-        b.l(`${fieldName} ${handlerType}`);
-      }
-    });
-    w.func("NewRouter() *Router", (b) => {
-      b.l("return &Router{").i().l("middleware: make([]MiddlewareFunc, 0),").u().l("}");
-    });
-    for (const endpoint of contract.endpoints) {
-      const methodName = toMethodName2(endpoint.fullName);
-      const fieldName = toFieldName(endpoint.fullName);
-      const handlerType = methodName + "Handler";
-      w.method("r *Router", methodName, `handler ${handlerType}`, "*Router", (b) => {
-        b.l(`r.${fieldName} = handler`).return("r");
-      });
+      const handlerName = `${toMethodName2(endpoint.fullName)}Handler`;
+      const inputType = toPascalCase5(endpoint.input.name);
+      const outputType = toPascalCase5(endpoint.output.name);
+      this.w.comment(`Handler type for ${endpoint.fullName}`).type(
+        handlerName,
+        `func(ctx *Context, input ${inputType}) (${outputType}, error)`
+      ).n();
     }
-    w.method("r *Router", "Use", "middleware MiddlewareFunc", "*Router", (b) => {
-      b.l("r.middleware = append(r.middleware, middleware)").return("r");
-    });
-    this.generateServeHTTP(contract.endpoints, w);
-    return w.toString();
-  }
-  generateServeHTTP(endpoints, w) {
-    w.method("r *Router", "ServeHTTP", "w http.ResponseWriter, req *http.Request", "", (b) => {
-      b.if("req.Method != http.MethodPost", (b2) => {
-        b2.l('http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)').return();
-      }).n();
-      b.var("request", "struct {").i().l('Method string          `json:"method"`').l('Params json.RawMessage `json:"params"`').u().l("}").n();
-      b.if("err := json.NewDecoder(req.Body).Decode(&request); err != nil", (b2) => {
-        b2.l('http.Error(w, fmt.Sprintf("Invalid request: %v", err), http.StatusBadRequest)').return();
-      }).n();
-      b.decl("ctx", "&Context{").i().l("Request:        req,").l("ResponseWriter: w,").l("Data:           make(map[string]interface{}),").u().l("}").n();
-      b.comment("Execute middleware chain").l("for _, middleware := range r.middleware {").i().decl("result", "middleware(ctx)").if("result.Error != nil", (b2) => {
-        b2.l('http.Error(w, fmt.Sprintf("Middleware error: %v", result.Error), http.StatusInternalServerError)').return();
-      }).if("result.Response != nil", (b2) => {
-        b2.comment("Middleware short-circuited with response").return();
-      }).l("ctx = result.Context").u().l("}").n();
-      const cases = endpoints.map((endpoint) => ({
-        value: `"${endpoint.fullName}"`,
-        fn: (b2) => {
-          const fieldName = toFieldName(endpoint.fullName);
-          b2.if(`r.${fieldName} == nil`, (b3) => {
-            b3.l('http.Error(w, "Handler not registered", http.StatusNotFound)').return();
-          }).n();
-          const inputTypeName = toPascalCase3(endpoint.input.name);
-          b2.var("input", inputTypeName);
-          b2.if("err := json.Unmarshal(request.Params, &input); err != nil", (b3) => {
-            b3.l('http.Error(w, fmt.Sprintf("Invalid params: %v", err), http.StatusBadRequest)').return();
-          }).n();
-          const validationFuncName = `Validate${inputTypeName}`;
-          b2.if(`err := ${validationFuncName}(input); err != nil`, (b3) => {
-            b3.l('w.Header().Set("Content-Type", "application/json")').l("w.WriteHeader(http.StatusBadRequest)");
-            b3.l("if validationErrs, ok := err.(ValidationErrors); ok {").i().l("json.NewEncoder(w).Encode(map[string]interface{}{").i().l('"error": "Validation failed",').l('"errors": validationErrs,').u().l("})").u().l("} else {").i().l("json.NewEncoder(w).Encode(map[string]interface{}{").i().l('"error": err.Error(),').u().l("})").u().l("}");
-            b3.return();
-          }).n();
-          b2.decl("result, err", `r.${fieldName}(ctx, input)`);
-          b2.ifErr((b3) => {
-            b3.l('w.Header().Set("Content-Type", "application/json")').l('json.NewEncoder(w).Encode(map[string]interface{}{"error": err.Error()})').return();
-          }).n();
-          b2.l('w.Header().Set("Content-Type", "application/json")').l('json.NewEncoder(w).Encode(map[string]interface{}{"result": result})').return();
-        }
-      }));
-      w.switch("request.Method", cases, (b2) => {
-        b2.l('http.Error(w, "Method not found", http.StatusNotFound)').return();
-      });
-    });
   }
 };
 
 // src/validation-generator.ts
-import { toPascalCase as toPascalCase4 } from "@xrpckit/codegen";
+import {
+  toPascalCase as toPascalCase6
+} from "@xrpckit/sdk";
 var GoValidationGenerator = class {
   w;
   packageName;
+  generatedValidations = /* @__PURE__ */ new Set();
   constructor(packageName = "server") {
     this.w = new GoBuilder();
     this.packageName = packageName;
   }
-  generateValidation(contract) {
+  /**
+   * Generate Go validation functions from a contract definition.
+   * @param contract - The contract definition (should have names assigned to inline types)
+   * @param collectedTypes - Optional pre-collected nested types from GoTypeCollector
+   */
+  generateValidation(contract, collectedTypes) {
     const w = this.w.reset();
+    this.generatedValidations.clear();
     const imports = /* @__PURE__ */ new Set(["fmt", "strings"]);
     const needsRegex = this.hasValidationRule(
       contract,
-      (rules) => rules.uuid || rules.regex && !rules.email
+      collectedTypes,
+      (rules) => !!(rules.uuid || rules.regex && !rules.email)
       // regex but not email (email uses mail)
     );
     const needsMail = this.hasValidationRule(
       contract,
-      (rules) => rules.email
+      collectedTypes,
+      (rules) => !!rules.email
     );
     const needsURL = this.hasValidationRule(
       contract,
-      (rules) => rules.url
+      collectedTypes,
+      (rules) => !!rules.url
     );
     if (needsRegex) imports.add("regexp");
     if (needsMail) imports.add("net/mail");
@@ -416,7 +1137,7 @@ var GoValidationGenerator = class {
       if (type.kind === "object" && type.properties) {
         this.generateTypeValidation(type, w);
       } else if (type.kind === "array" && type.elementType?.kind === "object" && type.elementType.properties) {
-        const elementTypeName = toPascalCase4(type.name) + "Item";
+        const elementTypeName = type.elementType.name ? toPascalCase6(type.elementType.name) : `${toPascalCase6(type.name)}Item`;
         const elementType = {
           name: elementTypeName,
           kind: "object",
@@ -425,6 +1146,18 @@ var GoValidationGenerator = class {
         this.generateTypeValidation(elementType, w);
       }
     }
+    if (collectedTypes) {
+      for (const collected of collectedTypes) {
+        if (collected.typeRef.kind === "object" && collected.typeRef.properties) {
+          const typeDefinition = {
+            name: collected.name,
+            kind: "object",
+            properties: collected.typeRef.properties
+          };
+          this.generateTypeValidation(typeDefinition, w);
+        }
+      }
+    }
     this.generateHelperFunctions(w);
     return w.toString();
   }
@@ -443,13 +1176,17 @@ var GoValidationGenerator = class {
     }).n();
   }
   generateTypeValidation(type, w) {
-    const typeName = toPascalCase4(type.name);
+    const typeName = toPascalCase6(type.name);
     const funcName = `Validate${typeName}`;
+    if (this.generatedValidations.has(funcName)) {
+      return;
+    }
+    this.generatedValidations.add(funcName);
     w.func(`${funcName}(input ${typeName}) error`, (b) => {
       b.var("errs", "ValidationErrors");
       if (type.properties) {
         for (const prop of type.properties) {
-          this.generatePropertyValidation(prop, "input", type, b);
+          this.generatePropertyValidation(prop, "input", b);
         }
       }
       b.if("len(errs) > 0", (b2) => {
@@ -458,97 +1195,160 @@ var GoValidationGenerator = class {
       b.return("nil");
     }).n();
   }
-  generatePropertyValidation(prop, prefix, parentType, w) {
-    const fieldName = toPascalCase4(prop.name);
+  generatePropertyValidation(prop, prefix, w) {
+    const fieldName = toPascalCase6(prop.name);
     const fieldPath = `${prefix}.${fieldName}`;
     const fieldPathStr = prop.name;
-    const actualType = this.getActualType(prop.type);
+    const unwrappedType = this.unwrapOptionalNullable(prop.type);
+    const isPointerType = this.isPointerType(prop.type);
+    if (isPointerType) {
+      w.comment(`Validate ${prop.name} when present`);
+      w.if(`${fieldPath} != nil`, (b) => {
+        this.generatePropertyValidationForValue(
+          prop,
+          `*${fieldPath}`,
+          fieldPathStr,
+          unwrappedType,
+          b,
+          false
+        );
+      });
+      return;
+    }
+    this.generatePropertyValidationForValue(
+      prop,
+      fieldPath,
+      fieldPathStr,
+      unwrappedType,
+      w,
+      prop.required
+    );
+  }
+  generatePropertyValidationForValue(prop, valuePath, fieldPathStr, typeRef, w, isRequired) {
+    const actualType = this.getActualType(typeRef);
     const isString = actualType === "string";
     const isNumber = actualType === "number";
-    const isArray = prop.type.kind === "array";
-    if (prop.required) {
+    const isArray = typeRef.kind === "array";
+    const enumValues = this.getEnumValues(typeRef);
+    const isEnum = enumValues !== null;
+    if (isRequired) {
       w.comment(`Validate ${prop.name}`);
-      if (isString) {
-        w.if(`${fieldPath} == ""`, (b) => {
-          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "is required",`).u().l(`})`);
+      if (isEnum || isString) {
+        w.if(`${valuePath} == ""`, (b) => {
+          b.l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: "is required",`).u().l("})");
         });
       } else if (isNumber) {
       } else if (isArray) {
-        w.if(`${fieldPath} == nil`, (b) => {
-          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "is required",`).u().l(`})`);
+        w.if(`${valuePath} == nil`, (b) => {
+          b.l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: "is required",`).u().l("})");
         });
       }
     }
+    if (isEnum && enumValues) {
+      const enumValuesStr = enumValues.join(", ");
+      const enumConditions = enumValues.map((v) => `${valuePath} != "${v}"`).join(" && ");
+      w.if(`${valuePath} != "" && ${enumConditions}`, (b) => {
+        b.l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be one of: ${enumValuesStr}",`).u().l("})");
+      });
+    }
     const validationRules = prop.validation || prop.type.validation;
     if (validationRules) {
-      if (!prop.required) {
+      if (!isRequired) {
         if (isString) {
-          w.if(`${fieldPath} != ""`, (b) => {
+          w.if(`${valuePath} != ""`, (b) => {
             const validationTypeRef = {
               kind: "primitive",
               baseType: actualType
             };
-            this.generateValidationRules(validationRules, fieldPath, fieldPathStr, validationTypeRef, b, false);
+            this.generateValidationRules(
+              validationRules,
+              valuePath,
+              fieldPathStr,
+              validationTypeRef,
+              b,
+              false
+            );
           });
         } else if (isNumber) {
           const validationTypeRef = {
             kind: "primitive",
             baseType: actualType
           };
-          this.generateValidationRules(validationRules, fieldPath, fieldPathStr, validationTypeRef, w, false);
+          this.generateValidationRules(
+            validationRules,
+            valuePath,
+            fieldPathStr,
+            validationTypeRef,
+            w,
+            false
+          );
         } else if (isArray) {
-          w.if(`${fieldPath} != nil`, (b) => {
-            this.generateValidationRules(validationRules, fieldPath, fieldPathStr, prop.type, b, false);
+          w.if(`${valuePath} != nil`, (b) => {
+            this.generateValidationRules(
+              validationRules,
+              valuePath,
+              fieldPathStr,
+              typeRef,
+              b,
+              false
+            );
           });
         } else {
-          this.generateValidationRules(validationRules, fieldPath, fieldPathStr, prop.type, w, false);
+          this.generateValidationRules(
+            validationRules,
+            valuePath,
+            fieldPathStr,
+            typeRef,
+            w,
+            false
+          );
         }
+      } else if (isArray) {
+        this.generateValidationRules(
+          validationRules,
+          valuePath,
+          fieldPathStr,
+          typeRef,
+          w,
+          true
+        );
       } else {
-        if (isArray) {
-          this.generateValidationRules(validationRules, fieldPath, fieldPathStr, prop.type, w, prop.required);
-        } else {
-          const validationTypeRef = {
-            kind: "primitive",
-            baseType: actualType
-          };
-          this.generateValidationRules(validationRules, fieldPath, fieldPathStr, validationTypeRef, w, prop.required);
-        }
+        const validationTypeRef = {
+          kind: "primitive",
+          baseType: actualType
+        };
+        this.generateValidationRules(
+          validationRules,
+          valuePath,
+          fieldPathStr,
+          validationTypeRef,
+          w,
+          true
+        );
       }
     }
-    if (prop.type.kind === "object" && prop.type.name) {
-      const nestedTypeName = toPascalCase4(prop.type.name);
+    if (typeRef.kind === "object" && typeRef.name) {
+      const nestedTypeName = toPascalCase6(typeRef.name);
       const nestedFuncName = `Validate${nestedTypeName}`;
-      w.if(`${fieldPath} != nil`, (b) => {
-        b.l(`if err := ${nestedFuncName}(${fieldPath}); err != nil {`).i().l(`if nestedErrs, ok := err.(ValidationErrors); ok {`).i().l(`errs = append(errs, nestedErrs...)`).u().l(`} else {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: err.Error(),`).u().l(`})`).u().l(`}`).u().l(`}`);
-      });
-    } else if (prop.type.kind === "object" && prop.type.properties) {
-      w.if(`${fieldPath} != nil`, (b) => {
-        for (const nestedProp of prop.type.properties || []) {
-          const inlineType = {
-            name: "",
-            kind: "object",
-            properties: prop.type.properties
-          };
-          this.generatePropertyValidation(nestedProp, fieldPath, inlineType, b);
-        }
-      });
+      w.l(`if err := ${nestedFuncName}(${valuePath}); err != nil {`).i().l("if nestedErrs, ok := err.(ValidationErrors); ok {").i().l("errs = append(errs, nestedErrs...)").u().l("} else {").i().l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l("Message: err.Error(),").u().l("})").u().l("}").u().l("}");
     }
-    if (prop.type.kind === "array" && prop.type.elementType) {
-      if (prop.type.elementType.kind === "object" && prop.type.elementType.name) {
-        const elementTypeName = toPascalCase4(prop.type.elementType.name);
+    if (typeRef.kind === "array" && typeRef.elementType) {
+      const elementTypeRef = this.unwrapOptionalNullable(typeRef.elementType);
+      if (elementTypeRef.kind === "object" && elementTypeRef.name) {
+        const elementTypeName = toPascalCase6(elementTypeRef.name);
         const elementFuncName = `Validate${elementTypeName}`;
-        w.l(`for i, item := range ${fieldPath} {`).i().l(`if err := ${elementFuncName}(item); err != nil {`).i().l(`if nestedErrs, ok := err.(ValidationErrors); ok {`).i().l(`for _, nestedErr := range nestedErrs {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   fmt.Sprintf("${fieldPathStr}[%%d].%%s", i, nestedErr.Field),`).l(`Message: nestedErr.Message,`).u().l(`})`).u().l(`}`).u().l(`}`).u().l(`}`).u().l(`}`);
-      } else if (prop.type.elementType.kind === "object" && prop.type.elementType.properties) {
-        w.l(`for i, item := range ${fieldPath} {`).i();
-        const inlineType = {
-          name: "",
-          kind: "object",
-          properties: prop.type.elementType.properties
-        };
-        for (const nestedProp of prop.type.elementType.properties || []) {
-          this.generatePropertyValidation(nestedProp, "item", inlineType, w);
+        const isElementPointer = this.isPointerType(typeRef.elementType);
+        w.l(`for i, item := range ${valuePath} {`).i();
+        if (isElementPointer) {
+          w.l("if item == nil { continue }");
+          w.l(`if err := ${elementFuncName}(*item); err != nil {`);
+        } else {
+          w.l(`if err := ${elementFuncName}(item); err != nil {`);
         }
-        w.u().l(`}`);
+        w.i().l("if nestedErrs, ok := err.(ValidationErrors); ok {").i().l("for _, nestedErr := range nestedErrs {").i().l("errs = append(errs, &ValidationError{").i().l(
+          `Field:   fmt.Sprintf("${fieldPathStr}[%%d].%%s", i, nestedErr.Field),`
+        ).l("Message: nestedErr.Message,").u().l("})").u().l("}").u().l("}").u().l("}").u().l("}");
+        w.u().l("}");
       }
     }
   }
@@ -557,169 +1357,570 @@ var GoValidationGenerator = class {
       if (rules.minLength !== void 0) {
         const minLengthCondition = isRequired ? `${fieldPath} != "" && len(${fieldPath}) < ${rules.minLength}` : `len(${fieldPath}) < ${rules.minLength}`;
         w.if(minLengthCondition, (b) => {
-          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: fmt.Sprintf("must be at least %d character(s)", ${rules.minLength}),`).u().l(`})`);
+          b.l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(
+            `Message: fmt.Sprintf("must be at least %d character(s)", ${rules.minLength}),`
+          ).u().l("})");
         });
       }
       if (rules.maxLength !== void 0) {
         w.if(`len(${fieldPath}) > ${rules.maxLength}`, (b) => {
-          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: fmt.Sprintf("must be at most %d character(s)", ${rules.maxLength}),`).u().l(`})`);
+          b.l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(
+            `Message: fmt.Sprintf("must be at most %d character(s)", ${rules.maxLength}),`
+          ).u().l("})");
         });
       }
       if (rules.email) {
         if (isRequired) {
           w.if(`${fieldPath} != ""`, (b) => {
-            b.l(`if _, err := mail.ParseAddress(${fieldPath}); err != nil {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid email address",`).u().l(`})`).u().l(`}`);
+            b.l(`if _, err := mail.ParseAddress(${fieldPath}); err != nil {`).i().l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid email address",`).u().l("})").u().l("}");
           });
         } else {
-          w.l(`if _, err := mail.ParseAddress(${fieldPath}); err != nil {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid email address",`).u().l(`})`).u().l(`}`);
+          w.l(`if _, err := mail.ParseAddress(${fieldPath}); err != nil {`).i().l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid email address",`).u().l("})").u().l("}");
         }
       }
       if (rules.url) {
         if (isRequired) {
           w.if(`${fieldPath} != ""`, (b) => {
-            b.l(`if u, err := url.Parse(${fieldPath}); err != nil || u.Scheme == "" || u.Host == "" {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid URL",`).u().l(`})`).u().l(`}`);
+            b.l(
+              `if u, err := url.Parse(${fieldPath}); err != nil || u.Scheme == "" || u.Host == "" {`
+            ).i().l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid URL",`).u().l("})").u().l("}");
           });
         } else {
-          w.l(`if u, err := url.Parse(${fieldPath}); err != nil || u.Scheme == "" || u.Host == "" {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid URL",`).u().l(`})`).u().l(`}`);
+          w.l(
+            `if u, err := url.Parse(${fieldPath}); err != nil || u.Scheme == "" || u.Host == "" {`
+          ).i().l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid URL",`).u().l("})").u().l("}");
         }
       }
       if (rules.uuid) {
         if (isRequired) {
           w.if(`${fieldPath} != ""`, (b) => {
-            b.l(`matched, _ := regexp.MatchString("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", ${fieldPath})`).n().l(`if !matched {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid UUID",`).u().l(`})`).u().l(`}`);
+            b.l(
+              `matched, _ := regexp.MatchString("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", ${fieldPath})`
+            ).n().l("if !matched {").i().l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid UUID",`).u().l("})").u().l("}");
           });
         } else {
-          w.l(`matched, _ := regexp.MatchString("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", ${fieldPath})`).n().l(`if !matched {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid UUID",`).u().l(`})`).u().l(`}`);
+          w.l(
+            `matched, _ := regexp.MatchString("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", ${fieldPath})`
+          ).n().l("if !matched {").i().l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid UUID",`).u().l("})").u().l("}");
         }
       }
       if (rules.regex && !rules.email && !rules.url && !rules.uuid) {
         if (isRequired) {
           w.if(`${fieldPath} != ""`, (b) => {
-            const escapedRegex = rules.regex.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-            b.l(`matched, _ := regexp.MatchString("${escapedRegex}", ${fieldPath})`).n().l(`if !matched {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must match the required pattern",`).u().l(`})`).u().l(`}`);
+            const escapedRegex = rules.regex?.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+            b.l(
+              `matched, _ := regexp.MatchString("${escapedRegex}", ${fieldPath})`
+            ).n().l("if !matched {").i().l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must match the required pattern",`).u().l("})").u().l("}");
           });
         } else {
-          const escapedRegex = rules.regex.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-          w.l(`matched, _ := regexp.MatchString("${escapedRegex}", ${fieldPath})`).n().l(`if !matched {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must match the required pattern",`).u().l(`})`).u().l(`}`);
+          const escapedRegex = rules.regex?.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+          w.l(
+            `matched, _ := regexp.MatchString("${escapedRegex}", ${fieldPath})`
+          ).n().l("if !matched {").i().l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must match the required pattern",`).u().l("})").u().l("}");
         }
       }
     } else if (typeRef.baseType === "number") {
       if (rules.min !== void 0) {
         w.if(`${fieldPath} < ${rules.min}`, (b) => {
-          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: fmt.Sprintf("must be at least %v", ${rules.min}),`).u().l(`})`);
+          b.l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: fmt.Sprintf("must be at least %v", ${rules.min}),`).u().l("})");
         });
       }
       if (rules.max !== void 0) {
         w.if(`${fieldPath} > ${rules.max}`, (b) => {
-          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: fmt.Sprintf("must be at most %v", ${rules.max}),`).u().l(`})`);
+          b.l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: fmt.Sprintf("must be at most %v", ${rules.max}),`).u().l("})");
         });
       }
       if (rules.int) {
         w.if(`float64(${fieldPath}) != float64(int64(${fieldPath}))`, (b) => {
-          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be an integer",`).u().l(`})`);
+          b.l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be an integer",`).u().l("})");
         });
       }
       if (rules.positive) {
         w.if(`${fieldPath} <= 0`, (b) => {
-          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be positive",`).u().l(`})`);
+          b.l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be positive",`).u().l("})");
         });
       }
       if (rules.negative) {
         w.if(`${fieldPath} >= 0`, (b) => {
-          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be negative",`).u().l(`})`);
+          b.l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be negative",`).u().l("})");
         });
       }
     } else if (typeRef.kind === "array") {
       const arrayCheckCondition = isRequired ? `${fieldPath} != nil` : `${fieldPath} != nil`;
       if (rules.minItems !== void 0) {
-        w.if(`${arrayCheckCondition} && len(${fieldPath}) < ${rules.minItems}`, (b) => {
-          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: fmt.Sprintf("must have at least %d item(s)", ${rules.minItems}),`).u().l(`})`);
-        });
+        w.if(
+          `${arrayCheckCondition} && len(${fieldPath}) < ${rules.minItems}`,
+          (b) => {
+            b.l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(
+              `Message: fmt.Sprintf("must have at least %d item(s)", ${rules.minItems}),`
+            ).u().l("})");
+          }
+        );
       }
       if (rules.maxItems !== void 0) {
-        w.if(`${arrayCheckCondition} && len(${fieldPath}) > ${rules.maxItems}`, (b) => {
-          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: fmt.Sprintf("must have at most %d item(s)", ${rules.maxItems}),`).u().l(`})`);
-        });
+        w.if(
+          `${arrayCheckCondition} && len(${fieldPath}) > ${rules.maxItems}`,
+          (b) => {
+            b.l("errs = append(errs, &ValidationError{").i().l(`Field:   "${fieldPathStr}",`).l(
+              `Message: fmt.Sprintf("must have at most %d item(s)", ${rules.maxItems}),`
+            ).u().l("})");
+          }
+        );
       }
     }
   }
-  hasValidationRule(contract, check) {
+  hasValidationRule(contract, collectedTypes, check) {
     for (const type of contract.types) {
-      if (type.properties) {
-        for (const prop of type.properties) {
-          if (prop.validation && check(prop.validation)) {
-            return true;
-          }
-          if (prop.type.properties) {
-            for (const nestedProp of prop.type.properties) {
-              if (nestedProp.validation && check(nestedProp.validation)) {
-                return true;
-              }
-            }
-          }
-          if (prop.type.elementType?.properties) {
-            for (const elemProp of prop.type.elementType.properties) {
-              if (elemProp.validation && check(elemProp.validation)) {
-                return true;
-              }
-            }
-          }
-        }
+      if (this.checkTypeForValidationRule(type.properties, check)) {
+        return true;
       }
       if (type.elementType?.validation && check(type.elementType.validation)) {
         return true;
       }
+      if (type.elementType?.properties && this.checkTypeForValidationRule(type.elementType.properties, check)) {
+        return true;
+      }
+    }
+    if (collectedTypes) {
+      for (const collected of collectedTypes) {
+        if (collected.typeRef.properties && this.checkTypeForValidationRule(collected.typeRef.properties, check)) {
+          return true;
+        }
+      }
     }
     return false;
   }
-  generateHelperFunctions(w) {
+  checkTypeForValidationRule(properties, check) {
+    if (!properties) return false;
+    for (const prop of properties) {
+      if (prop.validation && check(prop.validation)) {
+        return true;
+      }
+      if (this.checkTypeRefForValidationRule(prop.type, check)) {
+        return true;
+      }
+    }
+    return false;
   }
-  getActualType(typeRef) {
+  checkTypeRefForValidationRule(typeRef, check) {
+    if (typeRef.validation && check(typeRef.validation)) {
+      return true;
+    }
+    if (typeRef.properties && this.checkTypeForValidationRule(typeRef.properties, check)) {
+      return true;
+    }
+    if (typeRef.elementType) {
+      if (typeRef.elementType.validation && check(typeRef.elementType.validation)) {
+        return true;
+      }
+      if (typeRef.elementType.properties && this.checkTypeForValidationRule(typeRef.elementType.properties, check)) {
+        return true;
+      }
+    }
+    if ((typeRef.kind === "optional" || typeRef.kind === "nullable") && typeof typeRef.baseType === "object") {
+      if (this.checkTypeRefForValidationRule(typeRef.baseType, check)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  generateHelperFunctions(_w) {
+  }
+  unwrapOptionalNullable(typeRef) {
     if (typeRef.kind === "optional" || typeRef.kind === "nullable") {
       if (typeRef.baseType) {
         if (typeof typeRef.baseType === "string") {
-          return typeRef.baseType;
+          return { kind: "primitive", baseType: typeRef.baseType };
         }
-        return this.getActualType(typeRef.baseType);
+        return this.unwrapOptionalNullable(typeRef.baseType);
       }
     }
-    if (typeof typeRef.baseType === "string") {
-      return typeRef.baseType;
+    if (typeRef.kind === "union" && typeRef.unionTypes) {
+      const nonNullVariants = typeRef.unionTypes.filter(
+        (variant) => !(variant.kind === "literal" && variant.literalValue === null)
+      );
+      if (nonNullVariants.length === 1) {
+        return this.unwrapOptionalNullable(nonNullVariants[0]);
+      }
     }
-    if (typeRef.baseType) {
-      return this.getActualType(typeRef.baseType);
+    return typeRef;
+  }
+  getActualType(typeRef) {
+    const unwrapped = this.unwrapOptionalNullable(typeRef);
+    if (unwrapped.kind === "primitive" && typeof unwrapped.baseType === "string") {
+      return unwrapped.baseType;
+    }
+    if (typeof unwrapped.baseType === "string") {
+      return unwrapped.baseType;
+    }
+    if (unwrapped.baseType) {
+      return this.getActualType(unwrapped.baseType);
     }
     return "unknown";
   }
-  toPascalCase(str) {
-    return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  getEnumValues(typeRef) {
+    const unwrapped = this.unwrapOptionalNullable(typeRef);
+    if (unwrapped.kind === "enum" && unwrapped.enumValues) {
+      return unwrapped.enumValues.filter(
+        (v) => typeof v === "string"
+      );
+    }
+    return null;
+  }
+  isPointerType(typeRef) {
+    if (typeRef.kind === "nullable") {
+      return true;
+    }
+    if (typeRef.kind === "optional") {
+      if (typeRef.baseType && typeof typeRef.baseType !== "string") {
+        return this.isPointerType(typeRef.baseType);
+      }
+    }
+    if (typeRef.kind === "union" && typeRef.unionTypes) {
+      const nonNullVariants = typeRef.unionTypes.filter(
+        (variant) => !(variant.kind === "literal" && variant.literalValue === null)
+      );
+      if (nonNullVariants.length === 1) {
+        return true;
+      }
+    }
+    return false;
   }
 };
 
 // src/generator.ts
-var GoCodeGenerator = class extends BaseCodeGenerator {
-  typeGenerator;
-  serverGenerator;
-  validationGenerator;
-  constructor(config) {
-    super(config);
-    const packageName = config.packageName || "server";
-    this.typeGenerator = new GoTypeGenerator(packageName);
-    this.serverGenerator = new GoServerGenerator(packageName);
-    this.validationGenerator = new GoValidationGenerator(packageName);
-  }
-  generate(contract) {
+var support = {
+  supportedTypes: [...TYPE_KINDS],
+  supportedValidations: [...VALIDATION_KINDS],
+  notes: [
+    "Generates idiomatic Go code using standard library only",
+    "Uses net/http for HTTP handling",
+    "Uses encoding/json for JSON marshaling",
+    "Validation uses net/mail for email, net/url for URLs, regexp for patterns"
+  ]
+};
+function getPackageName(options) {
+  if (options && typeof options.packageName === "string" && options.packageName) {
+    return options.packageName;
+  }
+  return "server";
+}
+function isNullableType(typeRef) {
+  if (typeRef.kind === "nullable") {
+    return true;
+  }
+  if (typeRef.kind === "optional" && typeof typeRef.baseType === "object") {
+    return isNullableType(typeRef.baseType);
+  }
+  if (typeRef.kind === "union" && typeRef.unionTypes) {
+    const nonNullVariants = typeRef.unionTypes.filter(
+      (variant) => !(variant.kind === "literal" && variant.literalValue === null)
+    );
+    return nonNullVariants.length === 1;
+  }
+  return false;
+}
+function collectRequiredNullableFields(contract) {
+  const results = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const collectFromProperties = (properties, parentName) => {
+    for (const prop of properties) {
+      const propPath = `${parentName}.${prop.name}`;
+      if (prop.required && isNullableType(prop.type)) {
+        results.add(propPath);
+      }
+      collectFromTypeRef(prop.type, `${parentName}${toPascalCase7(prop.name)}`);
+    }
+  };
+  const collectFromTypeRef = (typeRef, contextName) => {
+    if (typeRef.kind === "optional" || typeRef.kind === "nullable") {
+      if (typeof typeRef.baseType === "object") {
+        collectFromTypeRef(typeRef.baseType, contextName);
+      }
+      return;
+    }
+    if (typeRef.kind === "object" && typeRef.properties) {
+      const typeName = typeRef.name ? toPascalCase7(typeRef.name) : contextName;
+      collectFromProperties(typeRef.properties, typeName);
+      return;
+    }
+    if (typeRef.kind === "array" && typeRef.elementType) {
+      collectFromTypeRef(typeRef.elementType, `${contextName}Item`);
+      return;
+    }
+    if (typeRef.kind === "record" && typeRef.valueType) {
+      collectFromTypeRef(typeRef.valueType, `${contextName}Value`);
+      return;
+    }
+    if (typeRef.kind === "tuple" && typeRef.tupleElements) {
+      typeRef.tupleElements.forEach((elem, index) => {
+        collectFromTypeRef(elem, `${contextName}V${index}`);
+      });
+      return;
+    }
+    if (typeRef.kind === "union" && typeRef.unionTypes) {
+      typeRef.unionTypes.forEach((variant, index) => {
+        collectFromTypeRef(variant, `${contextName}Variant${index}`);
+      });
+    }
+  };
+  const collectFromTypeDefinition = (typeDef, typeName) => {
+    if (visited.has(typeName)) return;
+    visited.add(typeName);
+    if (typeDef.properties) {
+      collectFromProperties(typeDef.properties, typeName);
+    }
+    if (typeDef.kind === "array" && typeDef.elementType) {
+      collectFromTypeRef(typeDef.elementType, `${typeName}Item`);
+    }
+  };
+  for (const type of contract.types) {
+    collectFromTypeDefinition(type, toPascalCase7(type.name));
+  }
+  for (const endpoint of contract.endpoints) {
+    collectFromTypeRef(endpoint.input, `${endpoint.fullName}.input`);
+    collectFromTypeRef(endpoint.output, `${endpoint.fullName}.output`);
+  }
+  return Array.from(results);
+}
+function generateGoServer(input) {
+  const { contract } = input;
+  const diagnostics = validateSupport(contract, support, "go-server");
+  const requiredNullableFields = collectRequiredNullableFields(contract);
+  for (const field of requiredNullableFields) {
+    diagnostics.push({
+      severity: "warning",
+      message: `Field "${field}" is required and nullable. Go cannot distinguish missing values from null, so validation only runs when the value is present.`
+    });
+  }
+  const hasErrors = diagnostics.some((issue) => issue.severity === "error");
+  if (hasErrors) {
+    return { files: [], diagnostics };
+  }
+  const packageName = getPackageName(input.options);
+  const typeCollector = new GoTypeCollector();
+  const collectedTypes = typeCollector.collectTypes(contract);
+  const typeGenerator = new GoTypeGenerator(packageName);
+  const serverGenerator = new GoServerGenerator(packageName);
+  const validationGenerator = new GoValidationGenerator(packageName);
+  return {
+    files: [
+      {
+        path: "types.go",
+        content: typeGenerator.generateTypes(contract, collectedTypes)
+      },
+      {
+        path: "router.go",
+        content: serverGenerator.generateServer(contract)
+      },
+      {
+        path: "validation.go",
+        content: validationGenerator.generateValidation(
+          contract,
+          collectedTypes
+        )
+      }
+    ],
+    diagnostics
+  };
+}
+var goTarget = {
+  name: "go-server",
+  generate: generateGoServer
+};
+
+// src/validation-mapper.ts
+import {
+  ValidationMapperBase
+} from "@xrpckit/sdk";
+var GoValidationMapper = class extends ValidationMapperBase {
+  /**
+   * Complete mapping of all validation kinds to Go validation code.
+   * TypeScript enforces exhaustiveness at compile time.
+   */
+  validationMapping = {
+    // String validations
+    minLength: (ctx) => this.handleMinLength(ctx),
+    maxLength: (ctx) => this.handleMaxLength(ctx),
+    email: (ctx) => this.handleEmail(ctx),
+    url: (ctx) => this.handleUrl(ctx),
+    uuid: (ctx) => this.handleUuid(ctx),
+    regex: (ctx) => this.handleRegex(ctx),
+    // Number validations
+    min: (ctx) => this.handleMin(ctx),
+    max: (ctx) => this.handleMax(ctx),
+    int: (ctx) => this.handleInt(ctx),
+    positive: (ctx) => this.handlePositive(ctx),
+    negative: (ctx) => this.handleNegative(ctx),
+    // Array validations
+    minItems: (ctx) => this.handleMinItems(ctx),
+    maxItems: (ctx) => this.handleMaxItems(ctx)
+  };
+  // --- String validation handlers ---
+  handleMinLength(ctx) {
+    const { fieldPath, value, isRequired } = ctx;
+    const condition = isRequired ? `${fieldPath} != "" && len(${fieldPath}) < ${value}` : `len(${fieldPath}) < ${value}`;
+    return {
+      validation: {
+        condition,
+        message: `fmt.Sprintf("must be at least %d character(s)", ${value})`,
+        skipIfEmpty: !isRequired
+      },
+      imports: ["fmt"]
+    };
+  }
+  handleMaxLength(ctx) {
+    const { fieldPath, value } = ctx;
+    return {
+      validation: {
+        condition: `len(${fieldPath}) > ${value}`,
+        message: `fmt.Sprintf("must be at most %d character(s)", ${value})`
+      },
+      imports: ["fmt"]
+    };
+  }
+  handleEmail(ctx) {
+    const { fieldPath, isRequired } = ctx;
+    const condition = `func() bool { _, err := mail.ParseAddress(${fieldPath}); return err != nil }()`;
+    return {
+      validation: {
+        condition,
+        message: `"must be a valid email address"`,
+        skipIfEmpty: !isRequired
+      },
+      imports: ["net/mail"]
+    };
+  }
+  handleUrl(ctx) {
+    const { fieldPath, isRequired } = ctx;
+    const condition = `func() bool { u, err := url.Parse(${fieldPath}); return err != nil || u.Scheme == "" || u.Host == "" }()`;
+    return {
+      validation: {
+        condition,
+        message: `"must be a valid URL"`,
+        skipIfEmpty: !isRequired
+      },
+      imports: ["net/url"]
+    };
+  }
+  handleUuid(ctx) {
+    const { fieldPath, isRequired } = ctx;
+    const uuidRegex = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$";
+    const condition = `func() bool { matched, _ := regexp.MatchString("${uuidRegex}", ${fieldPath}); return !matched }()`;
+    return {
+      validation: {
+        condition,
+        message: `"must be a valid UUID"`,
+        skipIfEmpty: !isRequired
+      },
+      imports: ["regexp"]
+    };
+  }
+  handleRegex(ctx) {
+    const { fieldPath, value, isRequired, allRules } = ctx;
+    if (allRules.email || allRules.url || allRules.uuid) {
+      return {
+        validation: {
+          condition: "false",
+          // Never triggers
+          message: `""`
+          // No message
+        }
+      };
+    }
+    const escapedRegex = String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    const condition = `func() bool { matched, _ := regexp.MatchString("${escapedRegex}", ${fieldPath}); return !matched }()`;
+    return {
+      validation: {
+        condition,
+        message: `"must match the required pattern"`,
+        skipIfEmpty: !isRequired
+      },
+      imports: ["regexp"]
+    };
+  }
+  // --- Number validation handlers ---
+  handleMin(ctx) {
+    const { fieldPath, value } = ctx;
+    return {
+      validation: {
+        condition: `${fieldPath} < ${value}`,
+        message: `fmt.Sprintf("must be at least %v", ${value})`
+      },
+      imports: ["fmt"]
+    };
+  }
+  handleMax(ctx) {
+    const { fieldPath, value } = ctx;
+    return {
+      validation: {
+        condition: `${fieldPath} > ${value}`,
+        message: `fmt.Sprintf("must be at most %v", ${value})`
+      },
+      imports: ["fmt"]
+    };
+  }
+  handleInt(ctx) {
+    const { fieldPath } = ctx;
+    return {
+      validation: {
+        condition: `float64(${fieldPath}) != float64(int64(${fieldPath}))`,
+        message: `"must be an integer"`
+      }
+    };
+  }
+  handlePositive(ctx) {
+    const { fieldPath } = ctx;
+    return {
+      validation: {
+        condition: `${fieldPath} <= 0`,
+        message: `"must be positive"`
+      }
+    };
+  }
+  handleNegative(ctx) {
+    const { fieldPath } = ctx;
+    return {
+      validation: {
+        condition: `${fieldPath} >= 0`,
+        message: `"must be negative"`
+      }
+    };
+  }
+  // --- Array validation handlers ---
+  handleMinItems(ctx) {
+    const { fieldPath, value } = ctx;
+    return {
+      validation: {
+        condition: `${fieldPath} != nil && len(${fieldPath}) < ${value}`,
+        message: `fmt.Sprintf("must have at least %d item(s)", ${value})`
+      },
+      imports: ["fmt"]
+    };
+  }
+  handleMaxItems(ctx) {
+    const { fieldPath, value } = ctx;
     return {
-      types: this.typeGenerator.generateTypes(contract),
-      server: this.serverGenerator.generateServer(contract),
-      validation: this.validationGenerator.generateValidation(contract)
+      validation: {
+        condition: `${fieldPath} != nil && len(${fieldPath}) > ${value}`,
+        message: `fmt.Sprintf("must have at most %d item(s)", ${value})`
+      },
+      imports: ["fmt"]
     };
   }
 };
 export {
   GoBuilder,
-  GoCodeGenerator,
   GoServerGenerator,
+  GoTypeCollector,
   GoTypeGenerator,
-  GoTypeMapper
+  GoTypeMapper,
+  GoValidationGenerator,
+  GoValidationMapper,
+  createGoBigIntPattern,
+  createGoDatePattern,
+  createGoEnumPattern,
+  createGoTuplePattern,
+  createGoUnionPattern,
+  goTarget
 };