@typra/emitter 0.2.0

package/dist/src/languages/rust/emitter.js

@@ -0,0 +1,1596 @@
+/**
+ * Rust code emitter — Declaration IR → Rust source code.
+ *
+ * Replaces `file.rs.njk` + `_macros.njk` (~1,072 lines of Nunjucks templates)
+ * with a typed TypeScript function that walks the FileDecl tree.
+ *
+ * The emitter produces Rust code using the struct + enum pattern for
+ * polymorphic types. Output is post-processed by `cargo fmt`.
+ *
+ * Key Rust-specific patterns:
+ *   - Polymorphic types use struct + XxxKind enum (not inheritance)
+ *   - Variant-specific fields live on enum variants, not child classes
+ *   - Polymorphic single-ref fields → serde_json::Value
+ *   - Ownership: String, Option<T>, Vec<T>
+ *   - Pattern matching for load/save of variant fields
+ *
+ * Structural blocks emitted (in order):
+ *   1. Header comment (auto-generated warning)
+ *   2. Imports (context, referenced types)
+ *   3. For each polymorphic type:
+ *      a. XxxKind enum with inline struct variants
+ *      b. impl Default for XxxKind
+ *   4. For each type:
+ *      a. Struct definition with #[derive(Debug, Clone, Default)]
+ *      b. impl block:
+ *         - new(), from_json(), from_yaml()
+ *         - load_from_value()
+ *         - kind_str() (polymorphic only)
+ *         - to_value(), to_json(), to_yaml()
+ *         - to_wire() (when wire mappings exist)
+ *         - Collection helpers
+ *         - Factory methods
+ *         - Method stubs (as trait)
+ */
+import { toSnakeCase } from "../../ir/utilities.js";
+/**
+ * Emit a description as a single-line `///` doc comment.
+ * Multi-line descriptions are collapsed to a single line.
+ */
+function emitDocComment(description, indent, lines) {
+    // Collapse multi-line descriptions to a single line
+    const oneLine = description.replace(/\r?\n/g, " ").replace(/\s+/g, " ").trim();
+    lines.push(`${indent}/// ${oneLine}`);
+}
+function renderLines(lines) {
+    while (lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    return `${lines.join("\n")}\n`;
+}
+/**
+ * Convert a string literal value to a PascalCase Rust variant name.
+ * e.g., "system" → "System", "tool" → "Tool", "text" → "Text"
+ */
+function toPascalCase(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+const RUST_KEYWORDS = new Set([
+    "as", "break", "const", "continue", "crate", "else", "enum", "extern",
+    "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod",
+    "move", "mut", "pub", "ref", "return", "self", "Self", "static", "struct",
+    "super", "trait", "true", "type", "unsafe", "use", "where", "while",
+    "async", "await", "dyn",
+]);
+function rustFieldName(name) {
+    const snake = toSnakeCase(name);
+    return RUST_KEYWORDS.has(snake) ? `r#${snake}` : snake;
+}
+/**
+ * Emit a Rust enum for a named string-literal type.
+ * Uses serde rename for string ↔ enum round-tripping.
+ */
+function emitStringEnum(enumDef, lines) {
+    const firstVariant = toPascalCase(enumDef.values[0]);
+    if (enumDef.isOpen) {
+        // Open enums carry String data in Other variant — no Copy
+        lines.push("#[derive(Debug, Clone, PartialEq, Eq, Hash)]");
+    }
+    else {
+        lines.push("#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]");
+    }
+    lines.push(`pub enum ${enumDef.name} {`);
+    for (const value of enumDef.values) {
+        const variant = toPascalCase(value);
+        lines.push(`    ${variant},`);
+    }
+    if (enumDef.isOpen) {
+        lines.push("    /// Unknown variant (open enum — accepts any string).");
+        lines.push("    Other(String),");
+    }
+    lines.push("}");
+    lines.push("");
+    // impl Default — first variant (only for closed enums; open enums use first variant too)
+    lines.push(`impl Default for ${enumDef.name} {`);
+    lines.push("    fn default() -> Self {");
+    lines.push(`        Self::${firstVariant}`);
+    lines.push("    }");
+    lines.push("}");
+    lines.push("");
+    // impl Display
+    lines.push(`impl std::fmt::Display for ${enumDef.name} {`);
+    lines.push("    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {");
+    lines.push("        match self {");
+    for (const value of enumDef.values) {
+        lines.push(`            Self::${toPascalCase(value)} => write!(f, "${value}"),`);
+    }
+    if (enumDef.isOpen) {
+        lines.push("            Self::Other(s) => write!(f, \"{}\", s),");
+    }
+    lines.push("        }");
+    lines.push("    }");
+    lines.push("}");
+    lines.push("");
+    // impl From<&str>
+    lines.push(`impl ${enumDef.name} {`);
+    lines.push("    pub fn from_str_opt(s: &str) -> Option<Self> {");
+    lines.push("        match s {");
+    for (const value of enumDef.values) {
+        lines.push(`            "${value}" => Some(Self::${toPascalCase(value)}),`);
+    }
+    if (enumDef.isOpen) {
+        lines.push("            other => Some(Self::Other(other.to_string())),");
+    }
+    else {
+        lines.push("            _ => None,");
+    }
+    lines.push("        }");
+    lines.push("    }");
+    lines.push("");
+    lines.push("    pub fn as_str(&self) -> &str {");
+    lines.push("        match self {");
+    for (const value of enumDef.values) {
+        lines.push(`            Self::${toPascalCase(value)} => "${value}",`);
+    }
+    if (enumDef.isOpen) {
+        lines.push("            Self::Other(s) => s.as_str(),");
+    }
+    lines.push("        }");
+    lines.push("    }");
+    lines.push("}");
+    lines.push("");
+}
+/**
+ * Type mapping from TypeSpec scalar types to Rust types.
+ */
+const RUST_TYPE_MAP = {
+    string: "String",
+    boolean: "bool",
+    int32: "i32",
+    int64: "i64",
+    float32: "f32",
+    float64: "f64",
+    integer: "i64",
+    float: "f64",
+    numeric: "f64",
+    number: "f64",
+    any: "serde_json::Value",
+    unknown: "serde_json::Value",
+    object: "serde_json::Value",
+    dictionary: "serde_json::Value",
+    array: "Vec<serde_json::Value>",
+};
+/**
+ * Emit a complete Rust source file from a FileDecl.
+ *
+ * @param file - File declaration to emit
+ * @param visitor - Expression visitor
+ * @param polymorphicTypeNames - Set of type names that have polymorphic dispatch
+ * @param childToParent - Map from child variant name to parent type name
+ */
+export function emitRustFile(file, visitor, polymorphicTypeNames, childToParent = new Map()) {
+    const lines = [];
+    const hasNonProtocol = file.types.some(t => !t.isProtocol);
+    const group = file.group || "";
+    // Header
+    lines.push("// Code generated by Typra emitter; DO NOT EDIT.");
+    lines.push("");
+    lines.push("#![allow(unused_imports, dead_code, non_camel_case_types, unused_variables, clippy::all)]");
+    lines.push("");
+    if (hasNonProtocol) {
+        // Context is always at the model root.
+        // From inside a group subfolder, we need to go up two levels: group → model root.
+        const contextPath = group ? "super::super::context" : "super::context";
+        lines.push(`use ${contextPath}::{LoadContext, SaveContext};`);
+    }
+    // Imports — post-process for Rust specifics
+    // In Rust, polymorphic child types are enum variants (not standalone structs),
+    // so we import ParentKind instead.
+    for (const imp of file.imports) {
+        const processedNames = [];
+        for (const name of imp.names) {
+            // Check if this name is a polymorphic child → import ParentKind
+            const parentName = childToParent.get(name);
+            if (parentName) {
+                const kindName = parentName + "Kind";
+                if (!processedNames.includes(kindName)) {
+                    processedNames.push(kindName);
+                }
+                continue;
+            }
+            processedNames.push(name);
+        }
+        if (processedNames.length === 0)
+            continue;
+        lines.push("");
+        const names = processedNames.sort().join(", ");
+        // Build the Rust module path based on group relationship
+        let modPath;
+        if (imp.group === group) {
+            // Same group (or both root): sibling module via super
+            modPath = `super::${toSnakeCase(imp.module)}`;
+        }
+        else if (imp.group) {
+            // Different non-empty group: go up to model root, then into the group
+            modPath = `super::super::${imp.group}::${toSnakeCase(imp.module)}`;
+        }
+        else {
+            // Root-level module accessed from inside a group subfolder
+            modPath = `super::super::${toSnakeCase(imp.module)}`;
+        }
+        if (processedNames.length === 1) {
+            lines.push(`use ${modPath}::${names};`);
+        }
+        else {
+            lines.push(`use ${modPath}::{${names}};`);
+        }
+    }
+    lines.push("");
+    // String-literal enum types
+    for (const enumDef of file.enums) {
+        emitStringEnum(enumDef, lines);
+    }
+    // Find the base type (the one that owns the polymorphic dispatch)
+    const baseType = file.types.find(t => t.polymorphicDispatch) || file.types[0];
+    const childTypes = file.types.filter(t => t !== baseType);
+    // Protocol types → emit as trait (no struct, no impl)
+    if (baseType.isProtocol) {
+        emitProtocolTrait(baseType, lines);
+        lines.push("");
+        return renderLines(lines);
+    }
+    // Collect base field names for variant field extraction
+    const baseFieldNames = new Set(baseType.fields.map(f => f.name));
+    // Emit enum for polymorphic types
+    if (baseType.polymorphicDispatch) {
+        emitKindEnum(baseType, childTypes, baseFieldNames, polymorphicTypeNames, lines);
+    }
+    // Emit struct + impl for the base type (only one struct per file in Rust)
+    emitStruct(baseType, polymorphicTypeNames, lines);
+    emitImpl(baseType, childTypes, baseFieldNames, visitor, polymorphicTypeNames, lines);
+    // Method stubs as trait
+    if (baseType.methods.length > 0) {
+        emitMethodTrait(baseType, lines);
+    }
+    // Trailing newlines for child types that were folded into the enum
+    for (const _ of childTypes) {
+        lines.push("");
+    }
+    lines.push("");
+    return renderLines(lines);
+}
+// ============================================================================
+// Kind Enum
+// ============================================================================
+function emitKindEnum(baseType, childTypes, baseFieldNames, polymorphicTypeNames, lines) {
+    const dispatch = baseType.polymorphicDispatch;
+    const enumName = baseType.typeName.name + "Kind";
+    lines.push("");
+    lines.push(`/// Variant-specific data for [\`${baseType.typeName.name}\`], discriminated by \`${dispatch.discriminatorField}\`.`);
+    lines.push("#[derive(Debug, Clone)]");
+    lines.push(`pub enum ${enumName} {`);
+    // Named variants
+    for (const variant of dispatch.variants) {
+        const childType = childTypes.find(ct => ct.typeName.name === variant.typeName.name);
+        const variantName = variant.typeName.name.replace(baseType.typeName.name, "") || variant.typeName.name;
+        const variantFields = childType
+            ? childType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+            : [];
+        lines.push(`    /// \`${dispatch.discriminatorField}\` = \`"${variant.value}"\``);
+        if (variantFields.length === 0) {
+            lines.push(`    ${variantName},`);
+        }
+        else {
+            lines.push(`    ${variantName} {`);
+            for (const field of variantFields) {
+                if (field.description) {
+                    emitDocComment(field.description, "        ", lines);
+                }
+                lines.push(`        ${rustFieldName(field.name)}: ${fieldType(field, polymorphicTypeNames)},`);
+            }
+            lines.push(`    },`);
+        }
+    }
+    // Wildcard/default variant
+    if (dispatch.defaultVariant) {
+        const defaultType = childTypes.find(ct => ct.typeName.name === dispatch.defaultVariant.typeName.name);
+        const isSelfRef = dispatch.defaultVariant.isSelfReference;
+        const variantName = isSelfRef
+            ? "Custom"
+            : (dispatch.defaultVariant.typeName.name.replace(baseType.typeName.name, "") || "Custom");
+        const variantFields = isSelfRef
+            ? []
+            : (defaultType
+                ? defaultType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+                : []);
+        lines.push(`    /// Wildcard / catch-all variant for unrecognized \`${dispatch.discriminatorField}\` values.`);
+        // Wildcard always has kind_name field
+        if (variantFields.length === 0) {
+            lines.push(`    ${variantName} {`);
+            lines.push(`        /// The raw \`${dispatch.discriminatorField}\` string for this unknown variant.`);
+            lines.push(`        ${toSnakeCase(dispatch.discriminatorField)}_name: String,`);
+            lines.push(`    },`);
+        }
+        else {
+            lines.push(`    ${variantName} {`);
+            for (const field of variantFields) {
+                if (field.description) {
+                    emitDocComment(field.description, "        ", lines);
+                }
+                lines.push(`        ${rustFieldName(field.name)}: ${fieldType(field, polymorphicTypeNames)},`);
+            }
+            lines.push(`        /// The raw \`${dispatch.discriminatorField}\` string for this unknown variant.`);
+            lines.push(`        ${toSnakeCase(dispatch.discriminatorField)}_name: String,`);
+            lines.push(`    },`);
+        }
+    }
+    lines.push("}");
+    lines.push("");
+    // impl Default for the enum
+    emitEnumDefault(baseType, childTypes, baseFieldNames, dispatch, polymorphicTypeNames, lines);
+}
+function emitEnumDefault(baseType, childTypes, baseFieldNames, dispatch, polymorphicTypeNames, lines) {
+    const enumName = baseType.typeName.name + "Kind";
+    lines.push(`impl Default for ${enumName} {`);
+    lines.push("    fn default() -> Self {");
+    if (dispatch.defaultVariant) {
+        // Default to the wildcard/custom variant
+        const isSelfRef = dispatch.defaultVariant.isSelfReference;
+        const variantName = isSelfRef
+            ? "Custom"
+            : (dispatch.defaultVariant.typeName.name.replace(baseType.typeName.name, "") || "Custom");
+        const defaultType = childTypes.find(ct => ct.typeName.name === dispatch.defaultVariant.typeName.name);
+        const variantFields = isSelfRef
+            ? []
+            : (defaultType
+                ? defaultType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+                : []);
+        if (variantFields.length === 0) {
+            lines.push(`        ${enumName}::${variantName} {`);
+            lines.push(`            ${toSnakeCase(dispatch.discriminatorField)}_name: String::new(),`);
+            lines.push("        }");
+        }
+        else {
+            lines.push(`        ${enumName}::${variantName} {`);
+            for (const field of variantFields) {
+                lines.push(`            ${rustFieldName(field.name)}: ${fieldDefault(field, polymorphicTypeNames)},`);
+            }
+            lines.push(`            ${toSnakeCase(dispatch.discriminatorField)}_name: String::new(),`);
+            lines.push("        }");
+        }
+    }
+    else if (dispatch.variants.length > 0) {
+        // Default to the first named variant
+        const firstVariant = dispatch.variants[0];
+        const childType = childTypes.find(ct => ct.typeName.name === firstVariant.typeName.name);
+        const variantName = firstVariant.typeName.name.replace(baseType.typeName.name, "") || firstVariant.typeName.name;
+        const variantFields = childType
+            ? childType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+            : [];
+        if (variantFields.length === 0) {
+            lines.push(`        ${enumName}::${variantName}`);
+        }
+        else {
+            lines.push(`        ${enumName}::${variantName} {`);
+            for (const field of variantFields) {
+                lines.push(`            ${rustFieldName(field.name)}: ${fieldDefault(field, polymorphicTypeNames)},`);
+            }
+            lines.push("        }");
+        }
+    }
+    lines.push("    }");
+    lines.push("}");
+}
+// ============================================================================
+// Struct Definition
+// ============================================================================
+function emitStruct(type, polymorphicTypeNames, lines) {
+    if (type.description) {
+        emitDocComment(type.description, "", lines);
+    }
+    if (type.wire) {
+        lines.push("#[derive(Debug, Clone, Default, serde::Serialize)]");
+        lines.push('#[serde(rename_all = "camelCase")]');
+    }
+    else {
+        lines.push("#[derive(Debug, Clone, Default)]");
+    }
+    lines.push(`pub struct ${type.typeName.name} {`);
+    for (const field of type.fields) {
+        // Skip discriminator field — it's represented by the XxxKind enum field
+        if (type.polymorphicDispatch && field.name === type.polymorphicDispatch.discriminatorField)
+            continue;
+        if (field.description) {
+            emitDocComment(field.description, "    ", lines);
+        }
+        lines.push(`    pub ${rustFieldName(field.name)}: ${fieldType(field, polymorphicTypeNames)},`);
+    }
+    // Add kind field for polymorphic types
+    if (type.polymorphicDispatch) {
+        lines.push(`    /// Variant-specific data, discriminated by \`${type.polymorphicDispatch.discriminatorField}\`.`);
+        lines.push(`    pub ${rustFieldName(type.polymorphicDispatch.discriminatorField)}: ${type.typeName.name}Kind,`);
+    }
+    lines.push("}");
+}
+// ============================================================================
+// Impl Block
+// ============================================================================
+function emitImpl(type, childTypes, baseFieldNames, visitor, polymorphicTypeNames, lines) {
+    const name = type.typeName.name;
+    lines.push("");
+    lines.push(`impl ${name} {`);
+    // new()
+    lines.push(`    /// Create a new ${name} with default values.`);
+    lines.push("    pub fn new() -> Self {");
+    lines.push("        Self::default()");
+    lines.push("    }");
+    lines.push("");
+    // from_json()
+    emitFromJson(name, lines);
+    // from_yaml()
+    emitFromYaml(name, lines);
+    // load_from_value()
+    emitLoadFromValue(name, type, childTypes, baseFieldNames, polymorphicTypeNames, lines);
+    // kind_str() for polymorphic types
+    if (type.polymorphicDispatch) {
+        emitKindStr(type, childTypes, lines);
+    }
+    // to_value()
+    emitToValue(name, type, childTypes, baseFieldNames, polymorphicTypeNames, lines);
+    // to_json() / to_yaml()
+    emitToJson(name, lines);
+    emitToYaml(name, lines);
+    // to_wire() (only when wire mappings exist)
+    if (type.wire) {
+        emitToWireMethod(type, lines);
+    }
+    // Dict accessor helpers (only for dict-category fields, not scalar value types)
+    for (const field of type.fields) {
+        if (field.category.kind === "dict") {
+            emitDictAccessor(field, lines);
+        }
+    }
+    // Collection helpers — include both base type and child type helpers
+    // (in Rust, child types are enum variants, so their helpers live on the parent impl)
+    const emittedHelpers = new Set();
+    const allHelpers = [...type.collectionHelpers];
+    for (const child of childTypes) {
+        for (const h of child.collectionHelpers) {
+            if (!emittedHelpers.has(h.propertyName)) {
+                allHelpers.push(h);
+            }
+        }
+    }
+    for (const helper of allHelpers) {
+        if (emittedHelpers.has(helper.propertyName))
+            continue;
+        emittedHelpers.add(helper.propertyName);
+        emitCollectionLoadHelper(helper, polymorphicTypeNames, lines);
+        emitCollectionSaveHelper(helper, lines);
+    }
+    // Factories
+    for (const factory of type.factories) {
+        emitFactory(name, factory, visitor, lines);
+    }
+    lines.push("}");
+    // Method trait stubs (handled separately)
+}
+// ============================================================================
+// from_json / from_yaml
+// ============================================================================
+function emitFromJson(name, lines) {
+    lines.push(`    /// Load ${name} from a JSON string.`);
+    lines.push(`    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {`);
+    lines.push("        let value: serde_json::Value = serde_json::from_str(json)?;");
+    lines.push("        Ok(Self::load_from_value(&value, ctx))");
+    lines.push("    }");
+    lines.push("");
+}
+function emitFromYaml(name, lines) {
+    lines.push(`    /// Load ${name} from a YAML string.`);
+    lines.push(`    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {`);
+    lines.push("        let value: serde_json::Value = serde_yaml::from_str(yaml)?;");
+    lines.push("        Ok(Self::load_from_value(&value, ctx))");
+    lines.push("    }");
+    lines.push("");
+}
+// ============================================================================
+// load_from_value
+// ============================================================================
+function emitLoadFromValue(name, type, childTypes, baseFieldNames, polymorphicTypeNames, lines) {
+    lines.push(`    /// Load ${name} from a \`serde_json::Value\`.`);
+    lines.push("    ///");
+    lines.push("    /// Calls `ctx.process_input` before field extraction.");
+    lines.push("    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {");
+    lines.push("        let value = ctx.process_input(value.clone());");
+    // Coercions
+    for (const c of type.load.coercions) {
+        emitCoercionBranch(name, c, type, childTypes, baseFieldNames, polymorphicTypeNames, lines);
+    }
+    // Polymorphic dispatch
+    if (type.polymorphicDispatch) {
+        emitPolymorphicLoad(name, type, childTypes, baseFieldNames, polymorphicTypeNames, lines);
+    }
+    else {
+        // Simple struct construction
+        lines.push("        Self {");
+        for (const a of type.load.assignments) {
+            lines.push(`            ${rustFieldName(a.fieldName)}: ${loadExpr(a, polymorphicTypeNames)},`);
+        }
+        lines.push("        }");
+    }
+    lines.push("    }");
+    lines.push("");
+}
+function emitCoercionBranch(typeName, c, type, childTypes, baseFieldNames, polymorphicTypeNames, lines) {
+    const check = rustCoercionCheck(c.scalarType);
+    if (!check)
+        return;
+    lines.push(`        ${check.ifLet} {`);
+    // For string coercions, rebind `s` → `value` so downstream references work
+    if (c.scalarType === "string") {
+        lines.push("            let value = s.to_string();");
+    }
+    const dispatch = type.polymorphicDispatch;
+    const discField = dispatch?.discriminatorField;
+    const enumName = typeName + "Kind";
+    // Build field assignments, handling discriminator → enum variant construction
+    const fieldAssignments = c.assignments.map(a => {
+        const snake = rustFieldName(a.fieldName);
+        if (a.isInput) {
+            // Check if the target field is optional or an enum
+            const targetField = type.fields.find(f => f.name === a.fieldName);
+            const isOptional = targetField?.isOptional ?? false;
+            // If target field is a named enum, use from_str_opt instead of .into()
+            if (targetField?.enumName && targetField.allowedValues.length > 0) {
+                const defaultVal = String(targetField.defaultValue || targetField.allowedValues[0]);
+                const enumExpr = `${targetField.enumName}::from_str_opt(&value).unwrap_or(${targetField.enumName}::${toPascalCase(defaultVal)})`;
+                return isOptional ? `${snake}: Some(${enumExpr})` : `${snake}: ${enumExpr}`;
+            }
+            const expr = isOptional ? "Some(value.into())" : "value.into()";
+            return `${snake}: ${expr}`;
+        }
+        // Check if this field is the discriminator — must construct enum variant
+        if (dispatch && a.fieldName === discField) {
+            const discSnake = toSnakeCase(discField);
+            // Find if the literal matches a named variant
+            const matchingVariant = dispatch.variants.find(v => v.value === a.literalValue);
+            if (matchingVariant) {
+                const variantName = matchingVariant.typeName.name.replace(typeName, "") || matchingVariant.typeName.name;
+                // Check if variant has fields — unit variants don't get braces
+                const childType = childTypes.find(ct => ct.typeName.name === matchingVariant.typeName.name);
+                const variantFields = childType
+                    ? childType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+                    : [];
+                if (variantFields.length === 0) {
+                    return `${discSnake}: ${enumName}::${variantName}`;
+                }
+                return `${discSnake}: ${enumName}::${variantName} { ..Default::default() }`;
+            }
+            // Otherwise use the wildcard/custom variant
+            if (dispatch.defaultVariant) {
+                const dvName = dispatch.defaultVariant.isSelfReference
+                    ? "Custom"
+                    : (dispatch.defaultVariant.typeName.name.replace(typeName, "") || "Custom");
+                return `${discSnake}: ${enumName}::${dvName} { ${discSnake}_name: "${a.literalValue}".to_string() }`;
+            }
+            return `${discSnake}: ${enumName}::default()`;
+        }
+        return `${snake}: "${a.literalValue}".to_string()`;
+    });
+    lines.push(`            return ${typeName} { ${fieldAssignments.join(", ")}, ..Default::default() };`);
+    lines.push("        }");
+}
+/**
+ * Get the Rust coercion check pattern for a scalar type.
+ */
+function rustCoercionCheck(scalarType) {
+    switch (scalarType) {
+        case "string":
+            return { ifLet: "if let Some(s) = value.as_str()" };
+        case "boolean":
+            return { ifLet: "if let Some(value) = value.as_bool()" };
+        case "float64":
+        case "float":
+        case "number":
+        case "numeric":
+            return { ifLet: "if let Some(value) = value.as_f64()" };
+        case "int32":
+        case "int64":
+        case "integer":
+            return { ifLet: "if let Some(value) = value.as_i64()" };
+        default:
+            return null;
+    }
+}
+/**
+ * Get the Rust expression to convert a coercion value to the target field type.
+ */
+function coercionIntoValue(scalarType) {
+    // `value` is already bound in the coercion branch
+    // For string coercions: value is String, .into() for String → String
+    // For numeric/bool: value is the extracted primitive
+    return "value.into()";
+}
+function emitPolymorphicLoad(name, type, childTypes, baseFieldNames, polymorphicTypeNames, lines) {
+    const dispatch = type.polymorphicDispatch;
+    const discSnake = rustFieldName(dispatch.discriminatorField);
+    const enumName = name + "Kind";
+    lines.push(`        let ${discSnake}_str = value.get("${dispatch.discriminatorField}").and_then(|v| v.as_str()).unwrap_or("");`);
+    lines.push(`        let ${discSnake} = match ${discSnake}_str {`);
+    // Named variants
+    for (const variant of dispatch.variants) {
+        const childType = childTypes.find(ct => ct.typeName.name === variant.typeName.name);
+        const variantName = variant.typeName.name.replace(name, "") || variant.typeName.name;
+        const variantFields = childType
+            ? childType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+            : [];
+        if (variantFields.length === 0) {
+            lines.push(`            "${variant.value}" => ${enumName}::${variantName},`);
+        }
+        else {
+            lines.push(`            "${variant.value}" => ${enumName}::${variantName} {`);
+            for (const field of variantFields) {
+                const assignment = variantLoadExpr(field, name, polymorphicTypeNames);
+                lines.push(`                ${rustFieldName(field.name)}: ${assignment},`);
+            }
+            lines.push(`            },`);
+        }
+    }
+    // Default / wildcard
+    if (dispatch.defaultVariant) {
+        const isSelfRef = dispatch.defaultVariant.isSelfReference;
+        const variantName = isSelfRef
+            ? "Custom"
+            : (dispatch.defaultVariant.typeName.name.replace(name, "") || "Custom");
+        const defaultType = childTypes.find(ct => ct.typeName.name === dispatch.defaultVariant.typeName.name);
+        const variantFields = isSelfRef
+            ? []
+            : (defaultType
+                ? defaultType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+                : []);
+        if (variantFields.length === 0) {
+            lines.push(`            _ => ${enumName}::${variantName} {`);
+            lines.push(`                ${discSnake}_name: ${discSnake}_str.to_string(),`);
+            lines.push(`            },`);
+        }
+        else {
+            lines.push(`            _ => ${enumName}::${variantName} {`);
+            for (const field of variantFields) {
+                const assignment = variantLoadExpr(field, name, polymorphicTypeNames);
+                lines.push(`                ${rustFieldName(field.name)}: ${assignment},`);
+            }
+            lines.push(`                ${discSnake}_name: ${discSnake}_str.to_string(),`);
+            lines.push(`            },`);
+        }
+    }
+    else {
+        lines.push(`            _ => ${enumName}::default(),`);
+    }
+    lines.push("        };");
+    // Construct the struct with base fields + kind
+    lines.push("        Self {");
+    for (const a of type.load.assignments) {
+        // Skip discriminator — it's stored in the enum field
+        if (a.fieldName === dispatch.discriminatorField)
+            continue;
+        lines.push(`            ${rustFieldName(a.fieldName)}: ${loadExpr(a, polymorphicTypeNames)},`);
+    }
+    lines.push(`            ${discSnake}: ${discSnake},`);
+    lines.push("        }");
+}
+// ============================================================================
+// kind_str
+// ============================================================================
+function emitKindStr(type, childTypes, lines) {
+    const dispatch = type.polymorphicDispatch;
+    const baseFieldNames = new Set(type.fields.map(f => f.name));
+    const enumName = type.typeName.name + "Kind";
+    const discSnake = rustFieldName(dispatch.discriminatorField);
+    lines.push(`    /// Returns the \`${dispatch.discriminatorField}\` discriminator string for this instance.`);
+    lines.push(`    pub fn ${discSnake}_str(&self) -> &str {`);
+    lines.push(`        match &self.${discSnake} {`);
+    for (const variant of dispatch.variants) {
+        const variantName = variant.typeName.name.replace(type.typeName.name, "") || variant.typeName.name;
+        const childType = childTypes.find(ct => ct.typeName.name === variant.typeName.name);
+        const variantFields = childType
+            ? childType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+            : [];
+        if (variantFields.length === 0) {
+            lines.push(`            ${enumName}::${variantName} => "${variant.value}",`);
+        }
+        else {
+            lines.push(`            ${enumName}::${variantName} { .. } => "${variant.value}",`);
+        }
+    }
+    if (dispatch.defaultVariant) {
+        const isSelfRef = dispatch.defaultVariant.isSelfReference;
+        const variantName = isSelfRef
+            ? "Custom"
+            : (dispatch.defaultVariant.typeName.name.replace(type.typeName.name, "") || "Custom");
+        lines.push(`            ${enumName}::${variantName} { ${discSnake}_name, .. } => ${discSnake}_name.as_str(),`);
+    }
+    lines.push("        }");
+    lines.push("    }");
+    lines.push("");
+}
+// ============================================================================
+// to_value
+// ============================================================================
+function emitToValue(name, type, childTypes, baseFieldNames, polymorphicTypeNames, lines) {
+    lines.push(`    /// Serialize ${name} to a \`serde_json::Value\`.`);
+    lines.push("    ///");
+    lines.push("    /// Calls `ctx.process_dict` after serialization.");
+    lines.push("    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {");
+    lines.push("        let mut result = serde_json::Map::new();");
+    // Write discriminator first
+    if (type.polymorphicDispatch) {
+        const discSnake = rustFieldName(type.polymorphicDispatch.discriminatorField);
+        lines.push(`        // Write the discriminator`);
+        lines.push(`        result.insert("${type.polymorphicDispatch.discriminatorField}".to_string(), serde_json::Value::String(self.${discSnake}_str().to_string()));`);
+    }
+    // Write base fields
+    if (type.save.assignments.length > 0) {
+        lines.push(`        // Write base fields`);
+    }
+    for (const a of type.save.assignments) {
+        // Skip discriminator — it's written explicitly above from kind_str()
+        if (type.polymorphicDispatch && a.fieldName === type.polymorphicDispatch.discriminatorField)
+            continue;
+        emitSaveField(a, "self.", polymorphicTypeNames, lines, "        ");
+    }
+    // Write variant-specific fields
+    if (type.polymorphicDispatch) {
+        emitVariantSave(type, childTypes, baseFieldNames, polymorphicTypeNames, lines);
+    }
+    lines.push("        ctx.process_dict(serde_json::Value::Object(result))");
+    lines.push("    }");
+    lines.push("");
+}
+function emitVariantSave(type, childTypes, baseFieldNames, polymorphicTypeNames, lines) {
+    const dispatch = type.polymorphicDispatch;
+    const enumName = type.typeName.name + "Kind";
+    const discSnake = rustFieldName(dispatch.discriminatorField);
+    lines.push("        // Write variant-specific fields");
+    lines.push(`        match &self.${discSnake} {`);
+    for (const variant of dispatch.variants) {
+        const childType = childTypes.find(ct => ct.typeName.name === variant.typeName.name);
+        const variantName = variant.typeName.name.replace(type.typeName.name, "") || variant.typeName.name;
+        const variantFields = childType
+            ? childType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+            : [];
+        if (variantFields.length === 0) {
+            lines.push(`            ${enumName}::${variantName} => {`);
+            lines.push("            }");
+        }
+        else {
+            const destructure = variantFields.map(f => rustFieldName(f.name)).join(", ");
+            lines.push(`            ${enumName}::${variantName} { ${destructure},  .. } => {`);
+            for (const field of variantFields) {
+                emitVariantSaveField(field, polymorphicTypeNames, type.typeName.name, lines);
+            }
+            lines.push("            }");
+        }
+    }
+    // Wildcard variant
+    if (dispatch.defaultVariant) {
+        const isSelfRef = dispatch.defaultVariant.isSelfReference;
+        const variantName = isSelfRef
+            ? "Custom"
+            : (dispatch.defaultVariant.typeName.name.replace(type.typeName.name, "") || "Custom");
+        const defaultType = childTypes.find(ct => ct.typeName.name === dispatch.defaultVariant.typeName.name);
+        const variantFields = isSelfRef
+            ? []
+            : (defaultType
+                ? defaultType.fields.filter(f => f.name !== dispatch.discriminatorField && !baseFieldNames.has(f.name))
+                : []);
+        if (variantFields.length === 0) {
+            lines.push(`            ${enumName}::${variantName} { ${discSnake}_name: _, .. } => {`);
+            lines.push("            }");
+        }
+        else {
+            const destructure = variantFields.map(f => rustFieldName(f.name)).join(", ");
+            lines.push(`            ${enumName}::${variantName} { ${destructure}, ${discSnake}_name: _, .. } => {`);
+            for (const field of variantFields) {
+                emitVariantSaveField(field, polymorphicTypeNames, type.typeName.name, lines);
+            }
+            lines.push("            }");
+        }
+    }
+    lines.push("        }");
+}
+// ============================================================================
+// to_json / to_yaml
+// ============================================================================
+function emitToJson(name, lines) {
+    lines.push(`    /// Serialize ${name} to a JSON string.`);
+    lines.push(`    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {`);
+    lines.push("        serde_json::to_string_pretty(&self.to_value(ctx))");
+    lines.push("    }");
+    lines.push("");
+}
+function emitToYaml(name, lines) {
+    lines.push(`    /// Serialize ${name} to a YAML string.`);
+    lines.push(`    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {`);
+    lines.push("        serde_yaml::to_string(&self.to_value(ctx))");
+    lines.push("    }");
+}
+// ============================================================================
+// to_wire — provider-specific wire format conversion
+// ============================================================================
+/**
+ * Emit a `to_wire(&self, provider: &str) -> serde_json::Value` method that
+ * serializes the struct via `serde_json::to_value`, then remaps field names
+ * according to provider-specific wire mappings.
+ *
+ * Only emitted when `type.wire` is non-null.
+ */
+function emitToWireMethod(type, lines) {
+    const wire = type.wire;
+    const name = type.typeName.name;
+    lines.push("");
+    lines.push(`    /// Convert to provider-specific wire format.`);
+    lines.push(`    pub fn to_wire(&self, provider: &str) -> serde_json::Value {`);
+    lines.push(`        let data = serde_json::to_value(self).unwrap_or_default();`);
+    lines.push(`        let mut result = serde_json::Map::new();`);
+    // Build the wire_map HashMap literal
+    lines.push(`        let wire_map: std::collections::HashMap<&str, std::collections::HashMap<&str, &str>> = std::collections::HashMap::from([`);
+    for (const mapping of wire.mappings) {
+        const entries = Object.entries(mapping.wireNames);
+        const inner = entries.map(([provider, wireName]) => `("${provider}", "${wireName}")`).join(", ");
+        lines.push(`            ("${mapping.fieldName}", std::collections::HashMap::from([${inner}])),`);
+    }
+    lines.push(`        ]);`);
+    // Iterate over serialized keys and remap (strict: only emit mapped fields)
+    lines.push(`        if let serde_json::Value::Object(map) = data {`);
+    lines.push(`            for (key, value) in map {`);
+    lines.push(`                if let Some(mapping) = wire_map.get(key.as_str()) {`);
+    lines.push(`                    if let Some(wire_name) = mapping.get(provider) {`);
+    lines.push(`                        result.insert(wire_name.to_string(), value);`);
+    lines.push(`                    }`);
+    lines.push(`                }`);
+    lines.push(`            }`);
+    lines.push(`        }`);
+    lines.push(`        serde_json::Value::Object(result)`);
+    lines.push(`    }`);
+}
+// ============================================================================
+// Dict accessor helpers
+// ============================================================================
+function emitDictAccessor(field, lines) {
+    const snake = rustFieldName(field.name);
+    lines.push(`    /// Returns typed reference to the map if the field is an object.`);
+    lines.push(`    /// Returns \`None\` if the field is null or not an object.`);
+    lines.push(`    pub fn as_${snake}_dict(&self) -> Option<&serde_json::Map<String, serde_json::Value>> {`);
+    lines.push(`        self.${snake}.as_object()`);
+    lines.push("    }");
+    lines.push("");
+}
+// ============================================================================
+// Collection helpers
+// ============================================================================
+function emitCollectionLoadHelper(helper, polymorphicTypeNames, lines) {
+    const fnName = `load_${toSnakeCase(helper.propertyName)}`;
+    const elemType = helper.elementTypeName.name;
+    lines.push("");
+    lines.push(`    /// Load a collection of ${elemType} from a JSON value.`);
+    if (helper.hasNameProperty) {
+        lines.push(`    /// Handles both array format \`[{...}]\` and dict format \`{"name": {...}}\`.`);
+    }
+    else {
+        lines.push(`    /// Handles both array format \`[{...}]\`.`);
+    }
+    lines.push(`    fn ${fnName}(data: &serde_json::Value, ctx: &LoadContext) -> Vec<${elemType}> {`);
+    lines.push("        match data {");
+    lines.push("            serde_json::Value::Array(arr) => {");
+    lines.push(`                arr.iter().map(|v| ${elemType}::load_from_value(v, ctx)).collect()`);
+    lines.push("            }");
+    lines.push("");
+    if (helper.hasNameProperty) {
+        // Dict format with name keys
+        const shorthandField = helper.innerFields.length > 0 ? helper.innerFields[0] : "value";
+        lines.push("            serde_json::Value::Object(obj) => {");
+        lines.push("                obj.iter()");
+        lines.push("                    .filter_map(|(name, value)| {");
+        lines.push("                        if value.is_array() {");
+        lines.push("                            return None;");
+        lines.push("                        }");
+        lines.push("                        let mut v = if value.is_object() {");
+        lines.push("                            value.clone()");
+        lines.push("                        } else {");
+        lines.push(`                            serde_json::json!({ "${shorthandField}": value })`);
+        lines.push("                        };");
+        lines.push('                        if let serde_json::Value::Object(ref mut m) = v {');
+        lines.push('                            m.entry("name".to_string()).or_insert_with(|| serde_json::Value::String(name.clone()));');
+        lines.push("                        }");
+        lines.push(`                        Some(${elemType}::load_from_value(&v, ctx))`);
+        lines.push("                    })");
+        lines.push("                    .collect()");
+        lines.push("            }");
+    }
+    lines.push("            _ => Vec::new(),");
+    lines.push("");
+    lines.push("        }");
+    lines.push("    }");
+    lines.push("");
+    // Save helper
+}
+function emitCollectionSaveHelper(helper, lines) {
+    const fnName = `save_${toSnakeCase(helper.propertyName)}`;
+    const elemType = helper.elementTypeName.name;
+    lines.push(`    /// Save a collection of ${elemType} to a JSON value.`);
+    lines.push(`    fn ${fnName}(items: &[${elemType}], ctx: &SaveContext) -> serde_json::Value {`);
+    if (helper.hasNameProperty) {
+        lines.push("");
+        lines.push('        if ctx.collection_format == "array" {');
+        lines.push("            return serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>());");
+        lines.push("        }");
+        lines.push("        // Object format: use name as key");
+        lines.push("        let mut result = serde_json::Map::new();");
+        lines.push("        for item in items {");
+        lines.push("            let mut item_data = match item.to_value(ctx) {");
+        lines.push('                serde_json::Value::Object(m) => m,');
+        lines.push('                other => { let mut m = serde_json::Map::new(); m.insert("value".to_string(), other); m },');
+        lines.push("            };");
+        lines.push('            if let Some(serde_json::Value::String(name)) = item_data.remove("name") {');
+        lines.push("                result.insert(name, serde_json::Value::Object(item_data));");
+        lines.push("            }");
+        lines.push("        }");
+        lines.push("        serde_json::Value::Object(result)");
+    }
+    else {
+        lines.push("");
+        lines.push("        serde_json::Value::Array(items.iter().map(|item| item.to_value(ctx)).collect::<Vec<_>>())");
+    }
+    lines.push("");
+    lines.push("    }");
+}
+// ============================================================================
+// Factory methods
+// ============================================================================
+function emitFactory(parentName, factory, visitor, lines) {
+    const params = Object.entries(factory.params)
+        .map(([pName, pType]) => `${toSnakeCase(pName)}: ${factoryParamType(pType)}`)
+        .join(", ");
+    lines.push(`    /// Create a ${parentName} with preset field values.`);
+    lines.push(`    pub fn ${factory.name}(${params}) -> Self {`);
+    lines.push(`        ${visitor.visitExpr(factory.body)}`);
+    lines.push("    }");
+}
+function factoryParamType(typeStr) {
+    switch (typeStr) {
+        case "string":
+            return "impl Into<String>";
+        case "unknown":
+        case "any":
+            return "impl Into<serde_json::Value>";
+        case "boolean":
+            return "bool";
+        case "int32":
+            return "i32";
+        case "int64":
+        case "integer":
+            return "i64";
+        case "float32":
+            return "f32";
+        case "float64":
+        case "float":
+            return "f64";
+        default:
+            return `impl Into<${typeStr}>`;
+    }
+}
+// ============================================================================
+// Method stub trait
+// ============================================================================
+function emitMethodTrait(type, lines) {
+    lines.push(`/// Helpers for [\`${type.typeName.name}\`]. Implement in a separate file.`);
+    lines.push(`pub trait ${type.typeName.name}Helpers {`);
+    for (const method of type.methods) {
+        if (method.description) {
+            emitDocComment(method.description, "    ", lines);
+        }
+        lines.push(`    fn ${toSnakeCase(method.name)}(&self) -> ${methodReturnType(method)};`);
+    }
+    lines.push("}");
+}
+function methodReturnType(method) {
+    if (method.returns === "string")
+        return "String";
+    return RUST_TYPE_MAP[method.returns] || method.returns;
+}
+// ============================================================================
+// Protocol trait emission
+// ============================================================================
+/** Map a protocol type string to a Rust type. */
+function protocolRustType(typeStr) {
+    // Handle nullable types
+    if (typeStr.endsWith("?")) {
+        const inner = typeStr.slice(0, -1);
+        return `Option<${protocolRustType(inner)}>`;
+    }
+    // Handle array types
+    if (typeStr.endsWith("[]")) {
+        const inner = typeStr.slice(0, -2);
+        return `Vec<${protocolRustType(inner)}>`;
+    }
+    if (typeStr === "Record<unknown>" || typeStr === "dictionary")
+        return "serde_json::Value";
+    if (typeStr === "unknown" || typeStr === "any")
+        return "serde_json::Value";
+    if (typeStr === "string")
+        return "String";
+    return RUST_TYPE_MAP[typeStr] || typeStr;
+}
+/**
+ * Emit a Rust trait for a protocol type.
+ * Uses #[async_trait] for async method support.
+ */
+function emitProtocolTrait(type, lines) {
+    const name = type.typeName.name;
+    if (type.description) {
+        emitDocComment(type.description, "", lines);
+    }
+    lines.push("#[async_trait::async_trait]");
+    lines.push(`pub trait ${name}: Send + Sync {`);
+    for (const method of type.methods) {
+        if (method.description) {
+            emitDocComment(method.description, "    ", lines);
+        }
+        const params = Object.entries(method.params)
+            .map(([pName, pType]) => `${toSnakeCase(pName)}: &${protocolRustType(pType)}`)
+            .join(", ");
+        const ret = protocolRustType(method.returns);
+        if (method.sync) {
+            // Synchronous method
+            if (method.optional) {
+                // Return type already includes nullability from ? suffix — don't double-wrap
+                lines.push(`    fn ${toSnakeCase(method.name)}(&self, ${params}) -> ${ret} {`);
+                lines.push("        None");
+                lines.push("    }");
+            }
+            else {
+                lines.push(`    fn ${toSnakeCase(method.name)}(&self, ${params}) -> ${ret};`);
+            }
+        }
+        else {
+            // Async method
+            if (method.optional) {
+                // Default implementation returns an error — providers override with real streaming
+                lines.push(`    async fn ${toSnakeCase(method.name)}(&self, ${params}) -> Result<${ret}, Box<dyn std::error::Error + Send + Sync>> {`);
+                lines.push(`        Err("not supported".into())`);
+                lines.push("    }");
+            }
+            else {
+                lines.push(`    async fn ${toSnakeCase(method.name)}(&self, ${params}) -> Result<${ret}, Box<dyn std::error::Error + Send + Sync>>;`);
+            }
+        }
+    }
+    lines.push("}");
+}
+// ============================================================================
+// Field type rendering
+// ============================================================================
+function fieldType(field, polymorphicTypeNames) {
+    // Named enum field — use the enum type
+    if (field.enumName && field.allowedValues.length > 0) {
+        return field.isOptional ? `Option<${field.enumName}>` : field.enumName;
+    }
+    const cat = field.category;
+    switch (cat.kind) {
+        case "scalar": {
+            const rustType = RUST_TYPE_MAP[cat.scalarType] || cat.scalarType;
+            // dict category handles always-Value separately; for scalar value types
+            // (any, object, unknown), optional fields are Option<Value>, required are Value.
+            // dictionary scalar is always Value (never Option) since it's a map type.
+            if (cat.scalarType === "dictionary") {
+                return "serde_json::Value";
+            }
+            return field.isOptional ? `Option<${rustType}>` : rustType;
+        }
+        case "complex": {
+            // Polymorphic references and "unknown" become serde_json::Value
+            // Always non-optional — Value::Null serves as the "absent" sentinel
+            if (polymorphicTypeNames.has(cat.typeName) || cat.typeName === "unknown") {
+                return "serde_json::Value";
+            }
+            return field.isOptional ? `Option<${cat.typeName}>` : cat.typeName;
+        }
+        case "collection_scalar": {
+            const elemType = RUST_TYPE_MAP[cat.scalarType] || cat.scalarType;
+            if (isValueType(cat.scalarType)) {
+                return field.isOptional ? "Option<Vec<serde_json::Value>>" : "Vec<serde_json::Value>";
+            }
+            return field.isOptional ? `Option<Vec<${elemType}>>` : `Vec<${elemType}>`;
+        }
+        case "collection_complex": {
+            if (cat.typeName === "unknown") {
+                return "Vec<serde_json::Value>";
+            }
+            return `Vec<${cat.typeName}>`;
+        }
+        case "dict": {
+            return "serde_json::Value";
+        }
+    }
+}
+function isValueType(scalarType) {
+    return scalarType === "any" || scalarType === "object" || scalarType === "dictionary" || scalarType === "unknown";
+}
+function fieldDefault(field, polymorphicTypeNames) {
+    // Named enum — default to field default value or first variant
+    if (field.enumName && field.allowedValues.length > 0) {
+        if (field.isOptional)
+            return "None";
+        const dv = typeof field.defaultValue === "string" ? field.defaultValue : null;
+        const defaultVal = dv && field.allowedValues.includes(dv) ? dv : field.allowedValues[0];
+        return `${field.enumName}::${toPascalCase(defaultVal)}`;
+    }
+    const cat = field.category;
+    switch (cat.kind) {
+        case "scalar": {
+            if (isValueType(cat.scalarType)) {
+                // dictionary is always Value (never Option); other value types may be optional
+                if (cat.scalarType !== "dictionary" && field.isOptional)
+                    return "None";
+                return "serde_json::Value::Null";
+            }
+            if (field.isOptional)
+                return "None";
+            const rustType = RUST_TYPE_MAP[cat.scalarType] || cat.scalarType;
+            if (rustType === "String")
+                return 'String::from("")';
+            if (rustType === "bool")
+                return "false";
+            if (rustType === "i32" || rustType === "i64")
+                return "0";
+            if (rustType === "f32" || rustType === "f64")
+                return "0.0";
+            return "Default::default()";
+        }
+        case "complex": {
+            // Polymorphic refs are always serde_json::Value, Null is the "absent" sentinel
+            if (polymorphicTypeNames.has(cat.typeName))
+                return "serde_json::Value::Null";
+            return field.isOptional ? "None" : "Default::default()";
+        }
+        case "collection_scalar":
+        case "collection_complex":
+            return field.isOptional ? "None" : "Vec::new()";
+        case "dict":
+            return "serde_json::Value::Null";
+    }
+}
+// ============================================================================
+// Load expression rendering (per-field)
+// ============================================================================
+function loadExpr(a, polymorphicTypeNames) {
+    const key = a.sourceName;
+    const cat = a.category;
+    // Named enum — parse from string via from_str_opt
+    if (a.enumName && a.allowedValues.length > 0) {
+        const dv = typeof a.defaultValue === "string" ? a.defaultValue : null;
+        const defaultVal = dv && a.allowedValues.includes(dv) ? dv : a.allowedValues[0];
+        if (a.isOptional) {
+            return `value.get("${key}").and_then(|v| v.as_str()).and_then(|s| ${a.enumName}::from_str_opt(s))`;
+        }
+        return `value.get("${key}").and_then(|v| v.as_str()).and_then(|s| ${a.enumName}::from_str_opt(s)).unwrap_or(${a.enumName}::${toPascalCase(defaultVal)})`;
+    }
+    switch (cat.kind) {
+        case "scalar":
+            return scalarLoadExpr(key, cat.scalarType, a.isOptional);
+        case "complex": {
+            if (polymorphicTypeNames.has(cat.typeName)) {
+                // Polymorphic ref → always serde_json::Value, Null is the "absent" sentinel
+                return `value.get("${key}").cloned().unwrap_or(serde_json::Value::Null)`;
+            }
+            if (a.isOptional) {
+                return `value.get("${key}").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| ${cat.typeName}::load_from_value(v, ctx))`;
+            }
+            return `value.get("${key}").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| ${cat.typeName}::load_from_value(v, ctx)).unwrap_or_default()`;
+        }
+        case "collection_scalar":
+            return collectionScalarLoadExpr(key, cat.scalarType, a.isOptional);
+        case "collection_complex":
+            return `value.get("${key}").map(|v| Self::load_${toSnakeCase(a.fieldName)}(v, ctx)).unwrap_or_default()`;
+        case "dict":
+            return `value.get("${key}").cloned().unwrap_or(serde_json::Value::Null)`;
+    }
+}
+function scalarLoadExpr(key, scalarType, isOptional) {
+    if (isValueType(scalarType)) {
+        // dictionary is never optional; any/object/unknown may be optional
+        if (scalarType === "dictionary") {
+            return `value.get("${key}").cloned().unwrap_or(serde_json::Value::Null)`;
+        }
+        return isOptional
+            ? `value.get("${key}").cloned()`
+            : `value.get("${key}").cloned().unwrap_or(serde_json::Value::Null)`;
+    }
+    switch (scalarType) {
+        case "string":
+            return isOptional
+                ? `value.get("${key}").and_then(|v| v.as_str()).map(|s| s.to_string())`
+                : `value.get("${key}").and_then(|v| v.as_str()).unwrap_or_default().to_string()`;
+        case "boolean":
+            return isOptional
+                ? `value.get("${key}").and_then(|v| v.as_bool())`
+                : `value.get("${key}").and_then(|v| v.as_bool()).unwrap_or(false)`;
+        case "int32":
+            return isOptional
+                ? `value.get("${key}").and_then(|v| v.as_i64()).map(|v| v as i32)`
+                : `value.get("${key}").and_then(|v| v.as_i64()).unwrap_or(0) as i32`;
+        case "int64":
+        case "integer":
+            return isOptional
+                ? `value.get("${key}").and_then(|v| v.as_i64())`
+                : `value.get("${key}").and_then(|v| v.as_i64()).unwrap_or(0)`;
+        case "float64":
+        case "float":
+        case "number":
+        case "numeric":
+            return isOptional
+                ? `value.get("${key}").and_then(|v| v.as_f64())`
+                : `value.get("${key}").and_then(|v| v.as_f64()).unwrap_or(0.0)`;
+        case "float32":
+            return isOptional
+                ? `value.get("${key}").and_then(|v| v.as_f64()).map(|v| v as f32)`
+                : `value.get("${key}").and_then(|v| v.as_f64()).unwrap_or(0.0) as f32`;
+        default:
+            return `value.get("${key}").cloned().unwrap_or(serde_json::Value::Null)`;
+    }
+}
+function collectionScalarLoadExpr(key, scalarType, isOptional) {
+    if (isValueType(scalarType)) {
+        return isOptional
+            ? `value.get("${key}").and_then(|v| v.as_array()).map(|arr| arr.to_vec())`
+            : `value.get("${key}").and_then(|v| v.as_array()).map(|arr| arr.to_vec()).unwrap_or_default()`;
+    }
+    switch (scalarType) {
+        case "string":
+            return isOptional
+                ? `value.get("${key}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect())`
+                : `value.get("${key}").and_then(|v| v.as_array()).map(|arr| arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect()).unwrap_or_default()`;
+        default:
+            return isOptional
+                ? `value.get("${key}").and_then(|v| v.as_array()).map(|arr| arr.to_vec())`
+                : `value.get("${key}").and_then(|v| v.as_array()).map(|arr| arr.to_vec()).unwrap_or_default()`;
+    }
+}
+/**
+ * Load expression for a variant field (used inside match arms).
+ */
+function variantLoadExpr(field, parentTypeName, polymorphicTypeNames) {
+    // Delegate to the same patterns as base field loading, but with "value" as the source
+    const key = field.name;
+    const cat = field.category;
+    // Named enum — parse from string via from_str_opt
+    if (field.enumName && field.allowedValues.length > 0) {
+        const defaultVal = String(field.defaultValue || field.allowedValues[0]);
+        if (field.isOptional) {
+            return `value.get("${key}").and_then(|v| v.as_str()).and_then(|s| ${field.enumName}::from_str_opt(s))`;
+        }
+        return `value.get("${key}").and_then(|v| v.as_str()).and_then(|s| ${field.enumName}::from_str_opt(s)).unwrap_or(${field.enumName}::${toPascalCase(defaultVal)})`;
+    }
+    switch (cat.kind) {
+        case "scalar":
+            return scalarLoadExpr(key, cat.scalarType, field.isOptional);
+        case "complex": {
+            if (polymorphicTypeNames.has(cat.typeName)) {
+                return field.isOptional
+                    ? `value.get("${key}").cloned()`
+                    : `value.get("${key}").cloned().unwrap_or(serde_json::Value::Null)`;
+            }
+            if (field.isOptional) {
+                return `value.get("${key}").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| ${cat.typeName}::load_from_value(v, ctx))`;
+            }
+            return `value.get("${key}").filter(|v| v.is_object() || v.is_array() || v.is_string()).map(|v| ${cat.typeName}::load_from_value(v, ctx)).unwrap_or_default()`;
+        }
+        case "collection_scalar":
+            return collectionScalarLoadExpr(key, cat.scalarType, field.isOptional);
+        case "collection_complex":
+            // Collection in a variant — use the parent type's helper
+            return `value.get("${key}").map(|v| Self::load_${toSnakeCase(field.name)}(v, ctx)).unwrap_or_default()`;
+        case "dict":
+            return `value.get("${key}").cloned().unwrap_or(serde_json::Value::Null)`;
+    }
+}
+// ============================================================================
+// Save expression rendering (per-field)
+// ============================================================================
+function emitSaveField(a, prefix, polymorphicTypeNames, lines, indent) {
+    const key = a.targetName;
+    const fieldRef = `${prefix}${rustFieldName(a.fieldName)}`;
+    const cat = a.category;
+    // Named enum — serialize via .to_string()
+    if (a.enumName) {
+        if (a.isOptional) {
+            lines.push(`${indent}if let Some(ref val) = ${fieldRef} {`);
+            lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::String(val.to_string()));`);
+            lines.push(`${indent}}`);
+        }
+        else {
+            lines.push(`${indent}result.insert("${key}".to_string(), serde_json::Value::String(${fieldRef}.to_string()));`);
+        }
+        return;
+    }
+    switch (cat.kind) {
+        case "scalar":
+            emitScalarSave(key, fieldRef, cat.scalarType, a.isOptional, lines, indent);
+            return;
+        case "complex": {
+            if (polymorphicTypeNames.has(cat.typeName)) {
+                // Polymorphic ref → always serde_json::Value, check .is_null()
+                lines.push(`${indent}if !${fieldRef}.is_null() {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), ${fieldRef}.clone());`);
+                lines.push(`${indent}}`);
+                return;
+            }
+            if (a.isOptional) {
+                lines.push(`${indent}if let Some(ref val) = ${fieldRef} {`);
+                lines.push(`${indent}    let nested = val.to_value(ctx);`);
+                lines.push(`${indent}    if !nested.is_null() {`);
+                lines.push(`${indent}        result.insert("${key}".to_string(), nested);`);
+                lines.push(`${indent}    }`);
+                lines.push(`${indent}}`);
+            }
+            else {
+                lines.push(`${indent}{`);
+                lines.push(`${indent}    let nested = ${fieldRef}.to_value(ctx);`);
+                lines.push(`${indent}    if !nested.is_null() {`);
+                lines.push(`${indent}        result.insert("${key}".to_string(), nested);`);
+                lines.push(`${indent}    }`);
+                lines.push(`${indent}}`);
+            }
+            return;
+        }
+        case "collection_scalar": {
+            if (a.isOptional) {
+                lines.push(`${indent}if let Some(ref items) = ${fieldRef} {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::to_value(items).unwrap_or(serde_json::Value::Null));`);
+                lines.push(`${indent}}`);
+            }
+            else {
+                lines.push(`${indent}if !${fieldRef}.is_empty() {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::to_value(&${fieldRef}).unwrap_or(serde_json::Value::Null));`);
+                lines.push(`${indent}}`);
+            }
+            return;
+        }
+        case "collection_complex": {
+            lines.push(`${indent}if !${fieldRef}.is_empty() {`);
+            lines.push(`${indent}    result.insert("${key}".to_string(), Self::save_${toSnakeCase(a.fieldName)}(&${fieldRef}, ctx));`);
+            lines.push(`${indent}}`);
+            return;
+        }
+        case "dict": {
+            lines.push(`${indent}if !${fieldRef}.is_null() {`);
+            lines.push(`${indent}    result.insert("${key}".to_string(), ${fieldRef}.clone());`);
+            lines.push(`${indent}}`);
+            return;
+        }
+    }
+}
+function emitScalarSave(key, fieldRef, scalarType, isOptional, lines, indent) {
+    if (isValueType(scalarType)) {
+        if (scalarType !== "dictionary" && isOptional) {
+            // Optional value types (any, object, unknown) are Option<Value>
+            lines.push(`${indent}if let Some(ref val) = ${fieldRef} {`);
+            lines.push(`${indent}    result.insert("${key}".to_string(), val.clone());`);
+            lines.push(`${indent}}`);
+        }
+        else {
+            // Required value types or dictionary (always Value, never Option)
+            lines.push(`${indent}if !${fieldRef}.is_null() {`);
+            lines.push(`${indent}    result.insert("${key}".to_string(), ${fieldRef}.clone());`);
+            lines.push(`${indent}}`);
+        }
+        return;
+    }
+    switch (scalarType) {
+        case "string":
+            if (isOptional) {
+                lines.push(`${indent}if let Some(ref val) = ${fieldRef} {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::String(val.clone()));`);
+                lines.push(`${indent}}`);
+            }
+            else {
+                lines.push(`${indent}if !${fieldRef}.is_empty() {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::String(${fieldRef}.clone()));`);
+                lines.push(`${indent}}`);
+            }
+            return;
+        case "boolean":
+            if (isOptional) {
+                lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::Bool(val));`);
+                lines.push(`${indent}}`);
+            }
+            else {
+                // Always write booleans
+                lines.push(`${indent}result.insert("${key}".to_string(), serde_json::Value::Bool(${fieldRef}));`);
+            }
+            return;
+        case "int32":
+        case "int64":
+        case "integer":
+            if (isOptional) {
+                lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::Number(serde_json::Number::from(val)));`);
+                lines.push(`${indent}}`);
+            }
+            else {
+                lines.push(`${indent}if ${fieldRef} != 0 {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::Number(serde_json::Number::from(${fieldRef})));`);
+                lines.push(`${indent}}`);
+            }
+            return;
+        case "float32":
+        case "float64":
+        case "float":
+        case "number":
+        case "numeric":
+            if (isOptional) {
+                lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Number::from_f64(val as f64).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null));`);
+                lines.push(`${indent}}`);
+            }
+            else {
+                lines.push(`${indent}if ${fieldRef} != 0.0 {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Number::from_f64(${fieldRef} as f64).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null));`);
+                lines.push(`${indent}}`);
+            }
+            return;
+    }
+}
+/**
+ * Emit a save expression for a variant field (destructured in a match arm).
+ */
+function emitVariantSaveField(field, polymorphicTypeNames, parentTypeName, lines) {
+    const key = field.name;
+    const fieldRef = rustFieldName(field.name);
+    const cat = field.category;
+    const indent = "                ";
+    // Named enum — serialize via .to_string()
+    if (field.enumName && field.allowedValues.length > 0) {
+        if (field.isOptional) {
+            lines.push(`${indent}if let Some(ref val) = ${fieldRef} {`);
+            lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::String(val.to_string()));`);
+            lines.push(`${indent}}`);
+        }
+        else {
+            lines.push(`${indent}result.insert("${key}".to_string(), serde_json::Value::String(${fieldRef}.to_string()));`);
+        }
+        return;
+    }
+    switch (cat.kind) {
+        case "scalar":
+            emitVariantScalarSave(key, fieldRef, cat.scalarType, field.isOptional, lines, indent);
+            return;
+        case "complex": {
+            if (polymorphicTypeNames.has(cat.typeName)) {
+                if (field.isOptional) {
+                    lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+                    lines.push(`${indent}    result.insert("${key}".to_string(), val.clone());`);
+                    lines.push(`${indent}}`);
+                }
+                else {
+                    lines.push(`${indent}if !${fieldRef}.is_null() {`);
+                    lines.push(`${indent}    result.insert("${key}".to_string(), ${fieldRef}.clone());`);
+                    lines.push(`${indent}}`);
+                }
+                return;
+            }
+            if (field.isOptional) {
+                lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), val.to_value(ctx));`);
+                lines.push(`${indent}}`);
+            }
+            else {
+                lines.push(`${indent}{`);
+                lines.push(`${indent}    let nested = ${fieldRef}.to_value(ctx);`);
+                lines.push(`${indent}    if !nested.is_null() {`);
+                lines.push(`${indent}        result.insert("${key}".to_string(), nested);`);
+                lines.push(`${indent}    }`);
+                lines.push(`${indent}}`);
+            }
+            return;
+        }
+        case "collection_scalar": {
+            if (field.isOptional) {
+                lines.push(`${indent}if let Some(items) = ${fieldRef} {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::to_value(items).unwrap_or(serde_json::Value::Null));`);
+                lines.push(`${indent}}`);
+            }
+            else {
+                lines.push(`${indent}if !${fieldRef}.is_empty() {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::to_value(${fieldRef}).unwrap_or(serde_json::Value::Null));`);
+                lines.push(`${indent}}`);
+            }
+            return;
+        }
+        case "collection_complex": {
+            lines.push(`${indent}if !${fieldRef}.is_empty() {`);
+            lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::Array(${fieldRef}.iter().map(|item| item.to_value(ctx)).collect()));`);
+            lines.push(`${indent}}`);
+            return;
+        }
+        case "dict": {
+            lines.push(`${indent}if !${fieldRef}.is_null() {`);
+            lines.push(`${indent}    result.insert("${key}".to_string(), ${fieldRef}.clone());`);
+            lines.push(`${indent}}`);
+            return;
+        }
+    }
+}
+function emitVariantScalarSave(key, fieldRef, scalarType, isOptional, lines, indent) {
+    if (isValueType(scalarType)) {
+        if (scalarType !== "dictionary" && isOptional) {
+            // Optional value types — variant fields are references, use direct pattern
+            lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+            lines.push(`${indent}    result.insert("${key}".to_string(), val.clone());`);
+            lines.push(`${indent}}`);
+        }
+        else {
+            lines.push(`${indent}if !${fieldRef}.is_null() {`);
+            lines.push(`${indent}    result.insert("${key}".to_string(), ${fieldRef}.clone());`);
+            lines.push(`${indent}}`);
+        }
+        return;
+    }
+    switch (scalarType) {
+        case "string":
+            if (isOptional) {
+                lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::String(val.clone()));`);
+                lines.push(`${indent}}`);
+            }
+            else {
+                lines.push(`${indent}if !${fieldRef}.is_empty() {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::String(${fieldRef}.clone()));`);
+                lines.push(`${indent}}`);
+            }
+            return;
+        case "boolean":
+            if (isOptional) {
+                lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::Bool(*val));`);
+                lines.push(`${indent}}`);
+            }
+            else {
+                lines.push(`${indent}result.insert("${key}".to_string(), serde_json::Value::Bool(*${fieldRef}));`);
+            }
+            return;
+        case "int32":
+        case "int64":
+        case "integer":
+            if (isOptional) {
+                lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::Number(serde_json::Number::from(*val)));`);
+                lines.push(`${indent}}`);
+            }
+            else {
+                lines.push(`${indent}if *${fieldRef} != 0 {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Value::Number(serde_json::Number::from(*${fieldRef})));`);
+                lines.push(`${indent}}`);
+            }
+            return;
+        case "float32":
+        case "float64":
+        case "float":
+        case "number":
+        case "numeric":
+            if (isOptional) {
+                lines.push(`${indent}if let Some(val) = ${fieldRef} {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Number::from_f64(*val as f64).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null));`);
+                lines.push(`${indent}}`);
+            }
+            else {
+                lines.push(`${indent}if *${fieldRef} != 0.0 {`);
+                lines.push(`${indent}    result.insert("${key}".to_string(), serde_json::Number::from_f64(*${fieldRef} as f64).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null));`);
+                lines.push(`${indent}}`);
+            }
+            return;
+    }
+}
+//# sourceMappingURL=emitter.js.map