deukpack 1.0.0

package/dist/codegen/CSharpGenerator.js

@@ -0,0 +1,2303 @@
+"use strict";
+/**
+ * DeukPack C# Generator
+ * C# code generation
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSharpGenerator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const DeukPackTypes_1 = require("../types/DeukPackTypes");
+const CodeGenerator_1 = require("./CodeGenerator");
+class CSharpGenerator extends CodeGenerator_1.CodeGenerator {
+    async generate(ast, _options) {
+        this._genOptions = _options;
+        // Generate separate files per IDL source file
+        const files = {};
+        // Group by source file
+        const fileGroups = this.groupBySourceFile(ast);
+        const metaTableDefsEarly = this.collectMetaTableDefinitions(ast);
+        this.validateTableLinkFields(ast, metaTableDefsEarly);
+        if (_options.efSupport) {
+            this._efMetaRowInfo = new Map();
+            for (const d of metaTableDefsEarly) {
+                this._efMetaRowInfo.set(d.rowTypeFull, { category: d.category, keyFieldNames: d.keyFieldNames });
+            }
+        }
+        else {
+            this._efMetaRowInfo = null;
+        }
+        for (const [sourceFile, definitions] of Object.entries(fileGroups)) {
+            const lines = [];
+            // Header
+            lines.push('/**');
+            lines.push(' * Autogenerated by DeukPack v1.0.0');
+            lines.push(' *');
+            lines.push(' * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING');
+            lines.push(' *  @generated');
+            lines.push(' */');
+            lines.push('using System;');
+            lines.push('using System.Collections;');
+            lines.push('using System.Collections.Generic;');
+            lines.push('using System.Text;');
+            lines.push('using System.IO;');
+            lines.push('using System.Runtime.Serialization;');
+            lines.push('using System.Linq;');
+            lines.push('using DeukPack.Protocol;');
+            if (_options.efSupport && definitions.structs.some((s) => this._efMetaRowInfo?.has(this.getStructFullName(s, ast)))) {
+                lines.push('using System.ComponentModel.DataAnnotations;');
+                lines.push('using System.ComponentModel.DataAnnotations.Schema;');
+            }
+            lines.push('');
+            // Group by namespace within this file
+            const namespaceGroups = this.groupByNamespace({
+                namespaces: ast.namespaces,
+                structs: definitions.structs,
+                enums: definitions.enums,
+                services: definitions.services,
+                typedefs: definitions.typedefs,
+                constants: definitions.constants,
+                includes: [],
+                annotations: {}
+            });
+            for (const [namespace, namespaceDefs] of Object.entries(namespaceGroups)) {
+                // Skip empty namespaces
+                const hasContent = namespaceDefs.enums.length > 0 ||
+                    namespaceDefs.structs.length > 0 ||
+                    namespaceDefs.typedefs.length > 0 ||
+                    namespaceDefs.constants.length > 0 ||
+                    namespaceDefs.services?.length > 0;
+                if (!hasContent) {
+                    continue;
+                }
+                // Namespace
+                lines.push(`namespace ${namespace}`);
+                lines.push('{');
+                lines.push('');
+                // Protocol type alias (DeukPack.Protocol namespace)
+                lines.push('  using DpProtocol = DeukPack.Protocol.DpProtocol;');
+                lines.push('');
+                // Generate typedefs FIRST (must be at namespace start in C#)
+                for (const typedef of namespaceDefs.typedefs) {
+                    lines.push(...this.generateTypedef(typedef));
+                    lines.push('');
+                }
+                // Generate enums
+                for (const enumDef of namespaceDefs.enums) {
+                    lines.push(...this.generateEnum(enumDef));
+                    lines.push('');
+                }
+                // Generate structs (pass current namespace for default value resolution e.g. msgInfo = { "msgId": id_e.req_login })
+                for (const struct of namespaceDefs.structs) {
+                    lines.push(...this.generateStruct(struct, ast, namespace));
+                    lines.push('');
+                }
+                // Generate constants inside a static class (C# requirement)
+                if (namespaceDefs.constants.length > 0) {
+                    lines.push('  public static class Constants');
+                    lines.push('  {');
+                    for (const constant of namespaceDefs.constants) {
+                        lines.push(...this.generateConstant(constant, ast));
+                    }
+                    lines.push('  }');
+                    lines.push('');
+                }
+                // Generate services (interface + version helper)
+                const services = namespaceDefs.services;
+                if (services && services.length > 0) {
+                    for (const svc of services) {
+                        lines.push(...this.generateService(svc, ast, namespace));
+                        lines.push('');
+                    }
+                }
+                lines.push('}');
+                lines.push('');
+            }
+            // Generate filename from source file
+            const filename = this.getFilenameFromSource(sourceFile);
+            files[filename] = lines.join('\n');
+        }
+        // table 키워드: 테이블 저장소(매니저)용 레지스트리 코드 항상 자동생성. 메타 테이블이 있으면 switch에 등록 → 리플렉션 없이 타입 접근.
+        const schemaFingerprint = this.computeSchemaFingerprint(ast);
+        files['MetaTableRegistry.g.cs'] = this.generateMetaTableRegistry(metaTableDefsEarly, schemaFingerprint);
+        if (_options.efSupport && metaTableDefsEarly.length > 0) {
+            files['DeukPackDbContext.g.cs'] = this.generateEfDbContext(metaTableDefsEarly);
+        }
+        return files;
+    }
+    /** Entity Framework Core: DbContext + DbSet per 메타 테이블. efSupport 시에만 호출. */
+    generateEfDbContext(metaTableDefs) {
+        const lines = [];
+        lines.push('/**');
+        lines.push(' * Autogenerated by DeukPack (EF support). DbContext for meta tables.');
+        lines.push(' * Add Microsoft.EntityFrameworkCore + provider (e.g. Sqlite) to your project.');
+        lines.push(' * @generated');
+        lines.push(' */');
+        lines.push('using System;');
+        lines.push('using Microsoft.EntityFrameworkCore;');
+        lines.push('');
+        lines.push('namespace Generated');
+        lines.push('{');
+        lines.push('  public class DeukPackDbContext : DbContext');
+        lines.push('  {');
+        lines.push('    public DeukPackDbContext(DbContextOptions<DeukPackDbContext> options) : base(options) { }');
+        lines.push('');
+        for (const d of metaTableDefs) {
+            const propName = d.category.charAt(0).toUpperCase() + d.category.slice(1).replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+            lines.push(`    public DbSet<${d.rowTypeFull}> ${propName} => Set<${d.rowTypeFull}>();`);
+        }
+        lines.push('');
+        lines.push('    protected override void OnModelCreating(ModelBuilder modelBuilder)');
+        lines.push('    {');
+        for (const d of metaTableDefs) {
+            lines.push(`      modelBuilder.Entity<${d.rowTypeFull}>().ToTable("${this.escapeCSharpStringContent(d.category)}");`);
+            if (d.keyFieldNames.length > 1) {
+                const keyProps = d.keyFieldNames.map((k) => k.charAt(0).toUpperCase() + k.slice(1).replace(/_([a-z])/g, (_, c) => c.toUpperCase()));
+                lines.push(`      modelBuilder.Entity<${d.rowTypeFull}>().HasKey(e => new { ${keyProps.map((p) => `e.${p}`).join(', ')} });`);
+            }
+        }
+        lines.push('    }');
+        lines.push('  }');
+        lines.push('}');
+        lines.push('');
+        return lines.join('\n');
+    }
+    /** tablelink<Table, Key>: 대상 테이블 row 타입에 지정한 키 필드가 없으면 오류. */
+    validateTableLinkFields(ast, metaTableDefs) {
+        for (const struct of ast.structs || []) {
+            for (const field of struct.fields || []) {
+                const t = field.type;
+                if (typeof t !== 'object' || !t || t.type !== 'tablelink')
+                    continue;
+                const tableCategory = t.tableCategory;
+                const keyField = t.keyField;
+                const def = metaTableDefs.find((d) => d.category === tableCategory || d.containerTypeFull.startsWith(tableCategory + '.'));
+                if (!def)
+                    continue;
+                const rowTypeFull = def.rowTypeFull;
+                const rowStruct = ast.structs?.find((s) => {
+                    const ns = this.getStructNamespace(s, ast);
+                    return (ns ? ns + '.' : '') + s.name === rowTypeFull;
+                });
+                const hasKey = rowStruct?.fields?.some((f) => f.name === keyField);
+                const hasLegacyMid = keyField === 'tuid' && rowStruct?.fields?.some((f) => f.name === 'meta_id');
+                if (!hasKey && !hasLegacyMid) {
+                    throw new DeukPackTypes_1.DeukPackException(`tablelink<${tableCategory}, ${keyField}>: 대상 테이블 row 타입 "${rowTypeFull}"에 키 필드 "${keyField}"가 없습니다.`);
+                }
+            }
+        }
+    }
+    /** include 포함 전체 AST 기준 와이어/구조 영향 스키마 지문. 정의 변경 시 값이 바뀌어 스키마 버전 변경 여부를 코드젠 수준에서 판단 가능. */
+    computeSchemaFingerprint(ast) {
+        const parts = [];
+        const nsList = [...(ast.namespaces || [])].sort((a, b) => (a.name || '').localeCompare(b.name || ''));
+        for (const ns of nsList) {
+            parts.push(`ns:${ns.name}`);
+        }
+        const structs = [...(ast.structs || [])].sort((a, b) => a.name.localeCompare(b.name));
+        for (const s of structs) {
+            parts.push(`record:${s.name}`);
+            const fields = [...(s.fields || [])].sort((a, b) => a.id - b.id);
+            for (const f of fields) {
+                parts.push(`f:${f.id}:${f.name}:${this.canonicalTypeStringForFingerprint(f.type)}`);
+            }
+        }
+        const enums = [...(ast.enums || [])].sort((a, b) => a.name.localeCompare(b.name));
+        for (const e of enums) {
+            const vals = Object.entries(e.values || {}).sort(([k1], [k2]) => k1.localeCompare(k2));
+            parts.push(`enum:${e.name}:${vals.map(([k, v]) => `${k}=${v}`).join(',')}`);
+        }
+        const typedefs = [...(ast.typedefs || [])].sort((a, b) => a.name.localeCompare(b.name));
+        for (const t of typedefs) {
+            parts.push(`typedef:${t.name}:${this.canonicalTypeStringForFingerprint(t.type)}`);
+        }
+        const str = parts.join('|');
+        const h = this.djb2Hash(str);
+        return (h >>> 0).toString(16).padStart(8, '0');
+    }
+    canonicalTypeStringForFingerprint(type) {
+        if (type == null)
+            return '?';
+        if (typeof type === 'string')
+            return type;
+        if (typeof type === 'object') {
+            if (type.type === 'list')
+                return `list<${this.canonicalTypeStringForFingerprint(type.elementType)}>`;
+            if (type.type === 'set')
+                return `set<${this.canonicalTypeStringForFingerprint(type.elementType)}>`;
+            if (type.type === 'map')
+                return `map<${this.canonicalTypeStringForFingerprint(type.keyType)},${this.canonicalTypeStringForFingerprint(type.valueType)}>`;
+            if (type.type === 'tablelink')
+                return `tablelink<${type.tableCategory},${type.keyField}>`;
+        }
+        return String(type);
+    }
+    djb2Hash(str) {
+        let h = 5381;
+        for (let i = 0; i < str.length; i++) {
+            h = ((h << 5) + h) + str.charCodeAt(i);
+        }
+        return h;
+    }
+    /** 메타 테이블(table/container) 목록 수집: 카테고리, 컨테이너 타입 풀네임, row 타입 풀네임, 키 필드명 목록 */
+    collectMetaTableDefinitions(ast) {
+        const list = [];
+        for (const struct of ast.structs || []) {
+            if (!this.isMetaContainerStruct(struct))
+                continue;
+            const ns = this.getStructNamespace(struct, ast);
+            if (!ns || !ns.endsWith('_meta'))
+                continue;
+            const category = ns.replace(/_meta$/, '');
+            const containerTypeFull = `${ns}.${struct.name}`;
+            const infosType = struct.fields && struct.fields[1] && typeof struct.fields[1].type === 'object' && struct.fields[1].type.type === 'map'
+                ? struct.fields[1].type.valueType
+                : null;
+            const rowTypeShort = infosType ? this.getCSharpType(infosType, ast, ns) : 'IDeukPack';
+            const rowTypeFull = rowTypeShort.includes('.') ? rowTypeShort : `${ns}.${rowTypeShort}`;
+            let keyFieldNames = struct.keyFieldNames;
+            if (!keyFieldNames?.length && struct.annotations?.['key']) {
+                const raw = String(struct.annotations['key']).replace(/^["']|["']$/g, '').trim();
+                if (raw)
+                    keyFieldNames = raw.split(',').map((s) => s.trim()).filter(Boolean);
+            }
+            if (!keyFieldNames?.length)
+                keyFieldNames = ['tuid'];
+            list.push({ category, containerTypeFull, rowTypeFull, keyFieldNames });
+        }
+        return list;
+    }
+    /** MetaTableRegistry.g.cs 생성 — GetContainerType/GetRowType/GetKeyFieldNames/CreateEmptyTemplate, SchemaFingerprint, 리플렉션 제거 */
+    generateMetaTableRegistry(defs, schemaFingerprint) {
+        const lines = [];
+        lines.push('/**');
+        lines.push(' * Autogenerated by DeukPack. Meta table registry — use instead of reflection for container/row type lookup and empty template.');
+        lines.push(' * When using table/container, ensure TableHeader and TableInfos types are available (e.g. include deuk.deuk or shared IDL).');
+        lines.push(' * @generated');
+        lines.push(' */');
+        lines.push('using System;');
+        lines.push('using DeukPack.Protocol;');
+        lines.push('');
+        lines.push('namespace Generated');
+        lines.push('{');
+        lines.push('  public static class MetaTableRegistry');
+        lines.push('  {');
+        lines.push('    /// <summary>include 포함 전체 스키마(구조/와이어 영향)의 지문. 정의 변경 시 값이 바뀌어 스키마 버전 변경 여부 판단에 사용.</summary>');
+        lines.push(`    public static readonly string SchemaFingerprint = "${this.escapeCSharpStringContent(schemaFingerprint)}";`);
+        lines.push('');
+        lines.push('    public static Type GetContainerType(string category)');
+        lines.push('    {');
+        lines.push('      if (category == null) return null;');
+        lines.push('      switch (category)');
+        lines.push('      {');
+        for (const d of defs) {
+            lines.push(`        case "${this.escapeCSharpStringContent(d.category)}": return typeof(${d.containerTypeFull});`);
+        }
+        lines.push('        default: return null;');
+        lines.push('      }');
+        lines.push('    }');
+        lines.push('');
+        lines.push('    public static Type GetRowType(string category)');
+        lines.push('    {');
+        lines.push('      if (category == null) return null;');
+        lines.push('      switch (category)');
+        lines.push('      {');
+        for (const d of defs) {
+            lines.push(`        case "${this.escapeCSharpStringContent(d.category)}": return typeof(${d.rowTypeFull});`);
+        }
+        lines.push('        default: return null;');
+        lines.push('      }');
+        lines.push('    }');
+        lines.push('');
+        lines.push('    /// <summary>카테고리별 키 필드명(단일 또는 복합). key 미선언 시 ["tuid"]. 매니저 검색·엑셀 칼럼 순서·보조 인덱스 판단용.</summary>');
+        lines.push('    public static System.Collections.Generic.IReadOnlyList<string> GetKeyFieldNames(string category)');
+        lines.push('    {');
+        lines.push('      if (category == null) return null;');
+        lines.push('      switch (category)');
+        lines.push('      {');
+        for (const d of defs) {
+            const arrLiteral = 'new string[] { ' + d.keyFieldNames.map((k) => `"${this.escapeCSharpStringContent(k)}"`).join(', ') + ' }';
+            lines.push(`        case "${this.escapeCSharpStringContent(d.category)}": return ${arrLiteral};`);
+        }
+        lines.push('        default: return null;');
+        lines.push('      }');
+        lines.push('    }');
+        lines.push('');
+        lines.push('    /// <summary>카테고리별 빈 메타 테이블 템플릿 생성 (Default_Header + 빈 Infos). 로더/툴에서 초기 컨테이너가 필요할 때 사용.</summary>');
+        lines.push('    public static IDeukMetaContainer CreateEmptyTemplate(string category)');
+        lines.push('    {');
+        lines.push('      if (category == null) return null;');
+        lines.push('      switch (category)');
+        lines.push('      {');
+        for (const d of defs) {
+            lines.push(`        case "${this.escapeCSharpStringContent(d.category)}": return (IDeukMetaContainer)${d.containerTypeFull}.CreateDefault();`);
+        }
+        lines.push('        default: return null;');
+        lines.push('      }');
+        lines.push('    }');
+        lines.push('  }');
+        lines.push('}');
+        lines.push('');
+        return lines.join('\n');
+    }
+    groupBySourceFile(ast) {
+        const groups = {};
+        const ensure = (sourceFile) => {
+            if (!groups[sourceFile]) {
+                groups[sourceFile] = { enums: [], structs: [], typedefs: [], constants: [], services: [] };
+            }
+        };
+        for (const enumDef of ast.enums) {
+            const sourceFile = enumDef.sourceFile || 'unknown';
+            ensure(sourceFile);
+            groups[sourceFile].enums.push(enumDef);
+        }
+        for (const struct of ast.structs) {
+            const sourceFile = struct.sourceFile || 'unknown';
+            ensure(sourceFile);
+            groups[sourceFile].structs.push(struct);
+        }
+        for (const typedef of ast.typedefs) {
+            const sourceFile = typedef.sourceFile || 'unknown';
+            ensure(sourceFile);
+            groups[sourceFile].typedefs.push(typedef);
+        }
+        for (const constant of ast.constants) {
+            const sourceFile = constant.sourceFile || 'unknown';
+            ensure(sourceFile);
+            groups[sourceFile].constants.push(constant);
+        }
+        for (const service of ast.services) {
+            const sourceFile = service.sourceFile || 'unknown';
+            ensure(sourceFile);
+            groups[sourceFile].services.push(service);
+        }
+        return groups;
+    }
+    getFilenameFromSource(sourceFile) {
+        // Extract filename without extension and path
+        const filename = sourceFile.split('/').pop()?.split('\\').pop() || 'unknown';
+        let nameWithoutExt = filename.replace(/\.thrift$/i, '').replace(/\.deuk$/i, '');
+        // .Thrift.cs 같은 중복 확장자 방지
+        if (nameWithoutExt.endsWith('.Thrift') || nameWithoutExt.endsWith('.thrift')) {
+            const baseName = nameWithoutExt.replace(/\.(Thrift|thrift)$/i, '');
+            return `${baseName}.cs`;
+        }
+        // Windows 예약어 방지 (COM, PRN, AUX, NUL, CON, LPT1-9 등)
+        const windowsReservedNames = ['CON', 'PRN', 'AUX', 'NUL', 'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9', 'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9'];
+        const upperName = nameWithoutExt.toUpperCase();
+        if (windowsReservedNames.includes(upperName) || nameWithoutExt === '' || nameWithoutExt === 'nul') {
+            // 예약어나 빈 이름이면 'unknown' 사용
+            return 'unknown.cs';
+        }
+        return `${nameWithoutExt}.cs`;
+    }
+    generateEnum(enumDef) {
+        const lines = [];
+        lines.push('/**');
+        lines.push(' * Autogenerated by DeukPack v1.0.0');
+        lines.push(' *');
+        lines.push(' * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING');
+        lines.push(' *  @generated');
+        lines.push(' */');
+        lines.push('');
+        const enumAttrs = enumDef.csharpAttributes;
+        if (enumAttrs?.length) {
+            for (const attr of enumAttrs) {
+                lines.push(`  ${attr}`);
+            }
+        }
+        lines.push(`  public enum ${enumDef.name}`);
+        lines.push('  {');
+        const entries = Object.entries(enumDef.values);
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            if (entry) {
+                const [name, value] = entry;
+                const comma = i < entries.length - 1 ? ',' : '';
+                const comment = enumDef.valueComments?.[name];
+                if (comment) {
+                    const escaped = comment.replace(/"/g, '\\"').replace(/\r?\n/g, ' ');
+                    lines.push(`    [System.ComponentModel.Description("${escaped}")]`);
+                }
+                lines.push(`    ${name} = ${value}${comma}`);
+            }
+        }
+        lines.push('  }');
+        return lines;
+    }
+    /** 테이블 행 타입 여부: 어떤 meta container의 infos map value type으로 쓰이는지 */
+    isTableRowType(struct, ast) {
+        const rowNs = this.getStructNamespace(struct, ast);
+        const rowFull = `${rowNs}.${struct.name}`;
+        for (const s of ast.structs || []) {
+            if (!this.isMetaContainerStruct(s) || !s.fields || s.fields.length < 2)
+                continue;
+            const infosType = s.fields[1].type;
+            if (typeof infosType !== 'object' || !infosType || infosType.type !== 'map')
+                continue;
+            const valueType = infosType.valueType;
+            if (!valueType)
+                continue;
+            const containerNs = this.getStructNamespace(s, ast);
+            const rowTypeShort = this.getCSharpType(valueType, ast, containerNs);
+            const rowTypeFull = rowTypeShort.includes('.') ? rowTypeShort : `${containerNs}.${rowTypeShort}`;
+            if (rowTypeFull === rowFull)
+                return true;
+        }
+        return false;
+    }
+    generateStruct(struct, ast, currentNamespace) {
+        const lines = [];
+        const ns = currentNamespace ?? this.getStructNamespace(struct, ast);
+        const fullName = this.getStructFullName(struct, ast);
+        const efMeta = this._efMetaRowInfo;
+        const efInfo = efMeta?.get(fullName) ?? null;
+        this._efCurrentRowInfo = efInfo;
+        // 테이블 행 record: 1-4번 예약. 5번부터만 사용. 옵션 tableRowReserved14 시 1-4 사용하면 컴파일 오류
+        const opts = this._genOptions;
+        if (opts?.tableRowReserved14 && this.isTableRowType(struct, ast) && struct.fields) {
+            const reserved = [1, 2, 3, 4];
+            for (const f of struct.fields) {
+                const id = typeof f.id === 'number' ? f.id : parseInt(String(f.id), 10);
+                if (!isNaN(id) && reserved.includes(id)) {
+                    throw new Error(`Table row record '${struct.name}' must not use field indices 1-4 (reserved for tuid, tid, name, note). Use 5 and above. Invalid field: ${f.id} ${f.name}`);
+                }
+            }
+        }
+        lines.push('/**');
+        lines.push(' * Autogenerated by DeukPack v1.0.0');
+        lines.push(' *');
+        lines.push(' * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING');
+        lines.push(' *  @generated');
+        lines.push(' */');
+        lines.push('');
+        const structAttrs = struct.csharpAttributes;
+        if (structAttrs?.length) {
+            for (const attr of structAttrs) {
+                lines.push(`  ${attr}`);
+            }
+        }
+        if (efInfo) {
+            lines.push(`  [Table("${this.escapeCSharpStringContent(efInfo.category)}")]`);
+        }
+        const isMetaContainer = this.isMetaContainerStruct(struct);
+        const metaContainerDataType = isMetaContainer && struct.fields && struct.fields.length >= 2
+            && typeof struct.fields[1].type === 'object' && struct.fields[1].type && struct.fields[1].type.type === 'map'
+            ? this.getCSharpType(struct.fields[1].type.valueType, ast, ns)
+            : null;
+        const implList = ['IDeukPack'];
+        if (isMetaContainer)
+            implList.push('IDeukMetaContainer');
+        if (metaContainerDataType)
+            implList.push(`IDeukMetaContainer<${metaContainerDataType}>`);
+        lines.push(`  [System.Serializable]`);
+        lines.push(`  public class ${struct.name} : ${implList.join(', ')}`);
+        lines.push('  {');
+        // Generate fields: 같은 네임스페이스면 타입 생략 → 내부처리는 항상 풀네임(ns)으로 구동
+        for (const field of struct.fields) {
+            lines.push(...this.generateField(field, ast, ns, struct));
+        }
+        // 기본값 공통: enum/구조체/primitive 모두 정적 Default_<필드명>으로 노출 (리플렉션·어셈블리 이슈 회피)
+        const defaultProps = [];
+        let msgIdLikeFieldName = null;
+        for (const field of struct.fields) {
+            const defaultExpr = this.getFieldDefaultExpression(field, ast, ns, struct);
+            if (defaultExpr === null)
+                continue;
+            const csharpType = this.getCSharpType(field.type, ast, ns);
+            const propName = this.capitalize(field.name);
+            defaultProps.push(`    public static ${csharpType} Default_${propName} => ${defaultExpr};`);
+            // 메시지 ID용: 타입이 MsgId 멤버를 가진 struct면 DefaultMessageId에서 참조 (이름 하드코딩 없음)
+            if (typeof field.type === 'string' && ast) {
+                const typeFull = this.resolveTypeToFullName(field.type, ns, ast);
+                const targetStruct = this.findStruct(ast, typeFull, ns);
+                if (targetStruct?.fields?.some(f => f.name.toLowerCase() === 'msgid')) {
+                    msgIdLikeFieldName = propName;
+                }
+            }
+        }
+        if (defaultProps.length > 0) {
+            lines.push('');
+            lines.push('    /// <summary>기본값 정적 노출 (enum/구조체 공통, 리플렉션 없이 조회)</summary>');
+            lines.push(...defaultProps);
+        }
+        if (msgIdLikeFieldName !== null) {
+            lines.push(`    /// <summary>Message ID for protocol handler registration (Default_* combination)</summary>`);
+            lines.push(`    public static int DefaultMessageId => Default_${msgIdLikeFieldName}.MsgId;`);
+        }
+        lines.push('');
+        lines.push('    // Serialization methods');
+        lines.push('    public void Write(DpProtocol oprot)');
+        lines.push('    {');
+        // default 있는 struct는 의미상 null이 될 수 없음 → 필드 초기화·Read() 쪽에서만 보장
+        lines.push('      DpRecord struc = new DpRecord("' + struct.name + '");');
+        lines.push('      oprot.WriteStructBegin(struc);');
+        for (const field of struct.fields) {
+            const fieldName = this.capitalize(field.name);
+            const writeCondition = this.generateWriteCondition(field, fieldName, ast, ns);
+            lines.push(`      ${writeCondition}`);
+            lines.push('      {');
+            lines.push('        DpColumn field = new DpColumn("' + field.name + '", ' + this.getTType(field.type, ast, ns) + ', ' + field.id + ');');
+            lines.push('        oprot.WriteFieldBegin(field);');
+            lines.push('        ' + this.generateWriteField(field, ast, ns));
+            lines.push('        oprot.WriteFieldEnd();');
+            lines.push('      }');
+        }
+        lines.push('      oprot.WriteFieldStop();');
+        lines.push('      oprot.WriteStructEnd();');
+        lines.push('    }');
+        lines.push('');
+        lines.push('    public void Read(DpProtocol iprot)');
+        lines.push('    {');
+        // 코드생성기 기준: Read() 진입 시 모든 필드를 기본값으로 초기화 → wire에 없는 필드는 항상 기본값 보장 (null/미초기화 방지)
+        for (const field of struct.fields) {
+            const fieldName = this.capitalize(field.name);
+            const rhs = this.generateCreateDefaultRhs(field, ast, ns, struct);
+            lines.push(`      this.${fieldName} = ${rhs};`);
+        }
+        lines.push('      DpColumn field;');
+        lines.push('      iprot.ReadStructBegin();');
+        lines.push('      while (true)');
+        lines.push('      {');
+        lines.push('        field = iprot.ReadFieldBegin();');
+        lines.push('        if (field.Type == DpWireType.Stop)');
+        lines.push('        {');
+        lines.push('          break;');
+        lines.push('        }');
+        lines.push('        switch (field.ID)');
+        lines.push('        {');
+        for (const field of struct.fields) {
+            lines.push('          case ' + field.id + ':');
+            lines.push('            if (field.Type == ' + this.getTType(field.type, ast, ns) + ')');
+            lines.push('            {');
+            lines.push('              ' + this.generateReadField(field, ast, ns));
+            const parentName = this.capitalize(field.name);
+            const hasDefault = field.defaultValue !== undefined;
+            const isStructField = typeof field.type === 'string' && ast && (this.isStructType(field.type, ast, ns) || this.isStructCSharpType(this.getCSharpType(field.type, ast, ns), ast));
+            if (hasDefault && isStructField && typeof field.type === 'string') {
+                for (const ensureLine of this.generateEnsureNestedDefaults(parentName, field.type, ast, ns)) {
+                    lines.push('              ' + ensureLine);
+                }
+            }
+            lines.push('            }');
+            lines.push('            else');
+            lines.push('            {');
+            lines.push('              DpProtocolUtil.Skip(iprot, field.Type);');
+            lines.push('            }');
+            lines.push('            break;');
+        }
+        lines.push('          default:');
+        lines.push('            DpProtocolUtil.Skip(iprot, field.Type);');
+        lines.push('            break;');
+        lines.push('        }');
+        lines.push('        iprot.ReadFieldEnd();');
+        lines.push('      }');
+        lines.push('      iprot.ReadStructEnd();');
+        lines.push('    }');
+        lines.push('');
+        // Generate Clone method
+        lines.push('    // Clone method');
+        lines.push('    public ' + struct.name + ' Clone()');
+        lines.push('    {');
+        lines.push('      var clone = new ' + struct.name + '();');
+        for (const field of struct.fields) {
+            const fieldName = this.capitalize(field.name);
+            lines.push('      ' + this.generateCloneField(field, fieldName, ast, ns));
+        }
+        lines.push('      return clone;');
+        lines.push('    }');
+        lines.push('');
+        // Explicit interface implementation for IDeukPack.Clone()
+        lines.push('    // Explicit interface implementation');
+        lines.push('    object IDeukPack.Clone()');
+        lines.push('    {');
+        lines.push('      return this.Clone();');
+        lines.push('    }');
+        lines.push('');
+        // CreateDefault: 재귀적으로 nested struct 초기화 (Clone/ToString과 동일 패턴)
+        lines.push('    // CreateDefault: recursive default instance');
+        lines.push('    public static ' + struct.name + ' CreateDefault()');
+        lines.push('    {');
+        lines.push('      var o = new ' + struct.name + '();');
+        for (const field of struct.fields) {
+            const fieldName = this.capitalize(field.name);
+            const rhs = this.generateCreateDefaultRhs(field, ast, ns, struct);
+            lines.push('      o.' + fieldName + ' = ' + rhs + ';');
+        }
+        lines.push('      return o;');
+        lines.push('    }');
+        lines.push('');
+        // Generate ToString method for object dump
+        lines.push('    public override string ToString() { return ToString(""); }');
+        lines.push('    public string ToString(string indent)');
+        lines.push('    {');
+        lines.push('      var sb = new StringBuilder();');
+        lines.push('      var ci = indent + "  ";');
+        lines.push('      sb.Append("' + struct.name + ' {");');
+        if (struct.fields.length === 0) {
+            lines.push('      sb.Append("}");');
+        }
+        else {
+            lines.push('      sb.AppendLine();');
+            for (const field of struct.fields) {
+                const fieldName = this.capitalize(field.name);
+                lines.push('      ' + this.generateToStringField(field, fieldName, ast, ns));
+            }
+            lines.push('      sb.Append(indent).Append("}");');
+        }
+        lines.push('      return sb.ToString();');
+        lines.push('    }');
+        lines.push('');
+        this._efCurrentRowInfo = null;
+        // Generate schema metadata (득팩 스키마 타입)
+        lines.push('    // Schema metadata');
+        lines.push('    public static DpSchema GetSchema()');
+        lines.push('    {');
+        lines.push('      return SchemaInfo.Value;');
+        lines.push('    }');
+        lines.push('');
+        const structDoc = struct.docComment != null ? this.escapeCSharpString(struct.docComment) : 'null';
+        const structAnn = struct.annotations != null && Object.keys(struct.annotations).length > 0
+            ? this.dictToCSharpAnnotations(struct.annotations)
+            : 'null';
+        lines.push('    private static readonly Lazy<DpSchema> SchemaInfo = new Lazy<DpSchema>(() =>');
+        lines.push('    {');
+        lines.push('      var schema = new DpSchema');
+        lines.push('      {');
+        lines.push('        Name = "' + this.escapeCSharpStringContent(struct.name) + '",');
+        lines.push('        Type = DpDefinitionKind.Struct,');
+        lines.push('        DocComment = ' + structDoc + ',');
+        lines.push('        Annotations = ' + structAnn + ',');
+        lines.push('        Fields = new Dictionary<int, DpFieldSchema>');
+        lines.push('        {');
+        const structFields = struct.fields ?? [];
+        for (let orderIdx = 0; orderIdx < structFields.length; orderIdx++) {
+            const field = structFields[orderIdx];
+            const fieldSchema = this.generateFieldSchema(field, ast, ns, orderIdx);
+            lines.push(`          { ${field.id}, ${fieldSchema} },`);
+        }
+        lines.push('        }');
+        lines.push('      };');
+        lines.push('      return schema;');
+        lines.push('    });');
+        if (isMetaContainer && struct.fields.length >= 2) {
+            const headerField = struct.fields[0];
+            const infosField = struct.fields[1];
+            const headerType = this.getCSharpType(headerField.type, ast, ns);
+            const infosValueType = typeof infosField.type === 'object' && infosField.type && infosField.type.type === 'map'
+                ? this.getCSharpType(infosField.type.valueType, ast, ns)
+                : 'IDeukPack';
+            lines.push('');
+            lines.push('    // IDeukMetaContainer: 리플렉션 없이 메타 매니저에서 접근');
+            lines.push(`    object IDeukMetaContainer.Header { get => Header; set => Header = (${headerType})value; }`);
+            lines.push(`    IReadOnlyDictionary<long, IDeukPack> IDeukMetaContainer.Infos => new DpMetaInfosWrapper<${infosValueType}>(Infos);`);
+            lines.push('    // IDeukMetaContainer<T>: 데이터 타입 지정 접근');
+            lines.push(`    IReadOnlyDictionary<long, ${infosValueType}> IDeukMetaContainer<${infosValueType}>.Data => Infos;`);
+        }
+        lines.push('  }');
+        return lines;
+    }
+    /** table 키워드: struct 이름이 table 또는 container(호환)이고 header + infos(map) 필드면 메타 테이블로 간주 */
+    isMetaContainerStruct(struct) {
+        if ((struct.name !== 'table' && struct.name !== 'container') || !struct.fields || struct.fields.length < 2)
+            return false;
+        const a = struct.fields[0].name.toLowerCase();
+        const b = struct.fields[1].name.toLowerCase();
+        if (a !== 'header' || b !== 'infos')
+            return false;
+        const infosType = struct.fields[1].type;
+        return typeof infosType === 'object' && infosType !== null && infosType.type === 'map';
+    }
+    generateFieldSchema(field, ast, currentNamespace, order = 0) {
+        const typeInfo = this.getSchemaTypeInfo(field.type, ast, currentNamespace);
+        const defaultValue = field.defaultValue !== undefined
+            ? this.serializeDefaultValueToSchemaExpression(field.defaultValue)
+            : 'null';
+        const docComment = field.docComment != null ? this.escapeCSharpString(field.docComment) : 'null';
+        const annotations = field.annotations != null && Object.keys(field.annotations).length > 0
+            ? this.dictToCSharpAnnotations(field.annotations)
+            : 'null';
+        const lines = [];
+        lines.push('new DpFieldSchema');
+        lines.push('            {');
+        lines.push(`              Id = ${field.id},`);
+        lines.push(`              Order = ${order},`);
+        lines.push(`              Name = "${this.escapeCSharpStringContent(field.name)}",`);
+        lines.push(`              Type = ${typeInfo.type},`);
+        lines.push(`              TypeName = "${this.escapeCSharpStringContent(typeInfo.typeName)}",`);
+        lines.push(`              Required = ${field.required ? 'true' : 'false'},`);
+        lines.push(`              DefaultValue = ${defaultValue},`);
+        lines.push(`              DocComment = ${docComment},`);
+        lines.push(`              Annotations = ${annotations}`);
+        lines.push('            }');
+        return lines.join('\n');
+    }
+    /** Full C# string literal including quotes (e.g. for DocComment = "..." ). */
+    escapeCSharpString(s) {
+        if (s == null)
+            return 'null';
+        return '"' + this.escapeCSharpStringContent(s) + '"';
+    }
+    /** Escape content for use inside C# "..." (no surrounding quotes). */
+    escapeCSharpStringContent(s) {
+        return String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\r/g, '\\r').replace(/\n/g, '\\n').replace(/\t/g, '\\t');
+    }
+    dictToCSharpAnnotations(ann) {
+        if (!ann || Object.keys(ann).length === 0)
+            return 'null';
+        const entries = Object.entries(ann).map(([k, v]) => `{ ${this.escapeCSharpString(k)}, ${this.escapeCSharpString(v)} }`).join(', ');
+        return `new Dictionary<string, string> { ${entries} }`;
+    }
+    /** 득팩 표준 타입명으로 TypeName 반환 (엑셀 Row2 등). 레거시 i16/i32/i64 → int16/int32/int64, list→요소타입만, map→map<K,V>. */
+    getSchemaTypeInfo(type, ast, currentNamespace) {
+        const legacyToStandard = { 'i8': 'int8', 'i16': 'int16', 'i32': 'int32', 'i64': 'int64' };
+        const toStandardTypeName = (t) => legacyToStandard[t] ?? t;
+        if (typeof type === 'string') {
+            const primitiveTypes = {
+                'bool': 'DpSchemaType.Bool',
+                'byte': 'DpSchemaType.Byte',
+                'int8': 'DpSchemaType.Byte',
+                'int16': 'DpSchemaType.I16',
+                'int32': 'DpSchemaType.I32',
+                'int64': 'DpSchemaType.I64',
+                'i8': 'DpSchemaType.Byte',
+                'i16': 'DpSchemaType.I16',
+                'i32': 'DpSchemaType.I32',
+                'i64': 'DpSchemaType.I64',
+                'float': 'DpSchemaType.Double',
+                'double': 'DpSchemaType.Double',
+                'string': 'DpSchemaType.String',
+                'binary': 'DpSchemaType.Binary',
+                'datetime': 'DpSchemaType.I64',
+                'timestamp': 'DpSchemaType.I64',
+                'date': 'DpSchemaType.I32',
+                'time': 'DpSchemaType.I32',
+                'decimal': 'DpSchemaType.String',
+                'numeric': 'DpSchemaType.String'
+            };
+            if (primitiveTypes[type])
+                return { type: primitiveTypes[type], typeName: toStandardTypeName(type) };
+            const resolvedStr = this.getResolvedWireTypeString(type, ast, currentNamespace);
+            if (primitiveTypes[resolvedStr])
+                return { type: primitiveTypes[resolvedStr], typeName: toStandardTypeName(resolvedStr) };
+            const resolved = ast ? this.resolveTypeToASTDefinition(resolvedStr, currentNamespace, ast) : null;
+            if (resolved?.kind === 'enum')
+                return { type: 'DpSchemaType.Enum', typeName: type };
+            if (resolved?.kind === 'record')
+                return { type: 'DpSchemaType.Struct', typeName: type };
+            if (resolved?.kind === 'primitive')
+                return { type: 'DpSchemaType.I32', typeName: toStandardTypeName(type) };
+            return { type: 'DpSchemaType.Struct', typeName: type };
+        }
+        if (typeof type === 'object' && type !== null) {
+            if (type.type === 'list') {
+                const elemInfo = this.getSchemaTypeInfo(type.elementType, ast, currentNamespace);
+                return { type: 'DpSchemaType.List', typeName: elemInfo.typeName };
+            }
+            if (type.type === 'set') {
+                const elemInfo = this.getSchemaTypeInfo(type.elementType, ast, currentNamespace);
+                return { type: 'DpSchemaType.Set', typeName: elemInfo.typeName };
+            }
+            if (type.type === 'map') {
+                const keyInfo = this.getSchemaTypeInfo(type.keyType, ast, currentNamespace);
+                const valueInfo = this.getSchemaTypeInfo(type.valueType, ast, currentNamespace);
+                return { type: 'DpSchemaType.Map', typeName: `map<${keyInfo.typeName}, ${valueInfo.typeName}>` };
+            }
+        }
+        return { type: 'DpSchemaType.Struct', typeName: 'object' };
+    }
+    /** C# expression for DpFieldSchema.DefaultValue (object) – full value for schema recovery. */
+    serializeDefaultValueToSchemaExpression(value) {
+        if (value === null || value === undefined)
+            return 'null';
+        if (typeof value === 'string')
+            return this.escapeCSharpString(value);
+        if (typeof value === 'number')
+            return value.toString();
+        if (typeof value === 'boolean')
+            return value ? 'true' : 'false';
+        if (Array.isArray(value)) {
+            const elements = value.map(v => `(object)(${this.serializeDefaultValueToSchemaExpression(v)})`).join(', ');
+            return `new List<object> { ${elements} }`;
+        }
+        if (typeof value === 'object') {
+            const entries = Object.entries(value).map(([k, v]) => `{ ${this.escapeCSharpString(k)}, (object)(${this.serializeDefaultValueToSchemaExpression(v)}) }`).join(', ');
+            return `new Dictionary<string, object> { ${entries} }`;
+        }
+        return 'null';
+    }
+    /**
+     * message<> 첫 필드 기본값: struct.annotations.msgId + 첫 필드 타입의 AST만 사용.
+     * 타입명/프로퍼티명 하드코딩 없음 — 첫 필드 struct에서 'result' 포함 필드·메시지 id용 필드 이름을 AST로 조회.
+     */
+    buildMessageFirstFieldDefault(parentStruct, field, ast, currentNamespace) {
+        const msgId = parentStruct.annotations?.['msgId'];
+        if (msgId == null || parentStruct.fields?.[0] !== field)
+            return null;
+        const typeStr = typeof field.type === 'string' ? field.type : '';
+        if (!typeStr)
+            return null;
+        const msgInfoFull = this.resolveTypeToFullName(typeStr, currentNamespace, ast);
+        const msgInfoStruct = this.findStruct(ast, typeStr, currentNamespace);
+        if (!msgInfoStruct?.fields?.length)
+            return null;
+        const idField = msgInfoStruct.fields.find(f => /msgid|msg_id|messageid/i.test(f.name || ''));
+        const resultField = msgInfoStruct.fields.find(f => (f.name || '').toLowerCase().includes('result'));
+        if (!resultField)
+            return null;
+        const resultTypeStr = typeof resultField.type === 'string' ? resultField.type : (resultField.type?.name ?? '');
+        if (!resultTypeStr)
+            return null;
+        const resultTypeFull = this.resolveTypeToFullName(resultTypeStr, this.getStructNamespace(msgInfoStruct, ast), ast);
+        const resultPropName = this.capitalize(resultField.name);
+        const idPropName = idField ? this.capitalize(idField.name) : 'MsgId'; // AST에 msgid 계열 필드 없을 때만 fallback
+        return `new ${msgInfoFull}() { ${idPropName} = ${msgId}, ${resultPropName} = ${resultTypeFull}.CreateDefault() }`;
+    }
+    /** 필드 기본값의 C# 우변 식 반환 (인스턴스 초기화·Default_ 정적 프로퍼티 공용). enum/struct/primitive 공통. */
+    getFieldDefaultExpression(field, ast, currentNamespace, parentStruct) {
+        if (parentStruct && ast && currentNamespace) {
+            const msgDefault = this.buildMessageFirstFieldDefault(parentStruct, field, ast, currentNamespace);
+            if (msgDefault != null)
+                return msgDefault;
+        }
+        if (field.defaultValue === undefined)
+            return null;
+        const objInit = this.getCSharpStructObjectInitializer(field.defaultValue, field.type, currentNamespace, ast);
+        if (objInit !== null)
+            return objInit;
+        const prim = this.getCSharpDefaultValue(field.defaultValue, field.type, ast, currentNamespace);
+        return prim !== 'null' ? prim : null;
+    }
+    generateField(field, ast, currentNamespace, parentStruct) {
+        const lines = [];
+        const fieldAttrs = field.csharpAttributes;
+        if (fieldAttrs?.length) {
+            for (const attr of fieldAttrs) {
+                lines.push(`    ${attr}`);
+            }
+        }
+        const efInfo = this._efCurrentRowInfo;
+        if (efInfo) {
+            if (efInfo.keyFieldNames.includes(field.name)) {
+                lines.push('    [Key]');
+            }
+            lines.push(`    [Column("${this.escapeCSharpStringContent(field.name)}")]`);
+        }
+        const csharpType = this.getCSharpType(field.type, ast, currentNamespace);
+        let defaultPart = '';
+        const defaultExpr = this.getFieldDefaultExpression(field, ast, currentNamespace, parentStruct);
+        if (defaultExpr !== null) {
+            defaultPart = ` = ${defaultExpr}`;
+        }
+        // Apache 호환: 프로퍼티로 생성 (EF Core 매핑·null 동작 일치). 기본값 있을 때만 끝에 ; (없으면 }; 불가)
+        lines.push(`    public ${csharpType} ${this.capitalize(field.name)} { get; set; }${defaultPart}${defaultPart ? ';' : ''}`);
+        return lines;
+    }
+    /** Struct의 풀네임 (namespace.shortName) */
+    getStructFullName(struct, ast) {
+        const ns = this.getStructNamespace(struct, ast);
+        const short = struct.name.includes('.') ? (struct.name.split('.').pop() ?? struct.name) : struct.name;
+        return `${ns}.${short}`;
+    }
+    /** Enum의 풀네임 (namespace.shortName) */
+    getEnumFullName(enumDef, ast) {
+        const ns = this.getEnumNamespace(enumDef, ast);
+        const short = enumDef.name.includes('.') ? (enumDef.name.split('.').pop() ?? enumDef.name) : enumDef.name;
+        return `${ns}.${short}`;
+    }
+    /** Typedef의 풀네임 (namespace.shortName) */
+    getTypedefFullName(typedef, ast) {
+        const ns = this.getTypedefNamespace(typedef, ast);
+        const short = typedef.name.includes('.') ? (typedef.name.split('.').pop() ?? typedef.name) : typedef.name;
+        return `${ns}.${short}`;
+    }
+    /** 타입 문자열을 풀네임으로 해석. AST의 struct/enum/typedef 기준으로만 매칭 (이름·점 휴리스틱 없음). */
+    resolveTypeToFullName(typeStr, currentNamespace, ast) {
+        if (!typeStr || typeof typeStr !== 'string')
+            return typeStr;
+        const primitives = ['bool', 'byte', 'int8', 'int16', 'int32', 'int64', 'float', 'double', 'string', 'binary', 'datetime', 'timestamp', 'date', 'time', 'decimal', 'numeric'];
+        if (primitives.includes(typeStr))
+            return typeStr;
+        if (!ast)
+            return typeStr;
+        if (typeStr.includes('.')) {
+            for (const s of ast.structs ?? []) {
+                if (this.getStructFullName(s, ast) === typeStr)
+                    return typeStr;
+            }
+            for (const e of ast.enums ?? []) {
+                if (this.getEnumFullName(e, ast) === typeStr)
+                    return typeStr;
+            }
+            for (const t of ast.typedefs ?? []) {
+                if (this.getTypedefFullName(t, ast) === typeStr)
+                    return typeStr;
+            }
+            return typeStr;
+        }
+        const sameNsFull = currentNamespace ? `${currentNamespace}.${typeStr}` : '';
+        if (sameNsFull) {
+            for (const s of ast.structs ?? []) {
+                if (this.getStructFullName(s, ast) === sameNsFull)
+                    return sameNsFull;
+            }
+            for (const e of ast.enums ?? []) {
+                if (this.getEnumFullName(e, ast) === sameNsFull)
+                    return sameNsFull;
+            }
+            for (const t of ast.typedefs ?? []) {
+                if (this.getTypedefFullName(t, ast) === sameNsFull)
+                    return sameNsFull;
+            }
+        }
+        const matches = [];
+        for (const s of ast.structs ?? []) {
+            const full = this.getStructFullName(s, ast);
+            if (full.endsWith('.' + typeStr))
+                matches.push(full);
+        }
+        for (const e of ast.enums ?? []) {
+            const full = this.getEnumFullName(e, ast);
+            if (full.endsWith('.' + typeStr))
+                matches.push(full);
+        }
+        for (const t of ast.typedefs ?? []) {
+            const full = this.getTypedefFullName(t, ast);
+            if (full.endsWith('.' + typeStr))
+                matches.push(full);
+        }
+        if (matches.length === 0)
+            return typeStr;
+        if (currentNamespace && matches.some(m => m.startsWith(currentNamespace + '.'))) {
+            return matches.find(m => m.startsWith(currentNamespace + '.')) ?? matches[0] ?? typeStr;
+        }
+        return matches[0] ?? typeStr;
+    }
+    /**
+     * AST 기준 타입 판별: 휴리스틱 없이 struct/enum/typedef 조회만 사용.
+     * AST에 정의되지 않은 타입(typedef/struct/enum에 없음) → primitive 로 간주.
+     * @returns 'primitive' | { kind: 'record', def } | { kind: 'enum', def } | null (미정의 타입, 득팩 표준 record)
+     */
+    resolveTypeToASTDefinition(type, currentNamespace, ast, visitedTypedefs = new Set()) {
+        if (!ast)
+            return null;
+        if (typeof type === 'object' && type !== null && 'type' in type) {
+            if (type.type === 'list' || type.type === 'set' || type.type === 'map')
+                return null;
+        }
+        if (typeof type !== 'string')
+            return null;
+        const fullName = this.resolveTypeToFullName(type, currentNamespace, ast);
+        if (ast.typedefs && ast.typedefs.length > 0) {
+            for (const typedef of ast.typedefs) {
+                if (this.getTypedefFullName(typedef, ast) !== fullName)
+                    continue;
+                if (visitedTypedefs.has(fullName))
+                    return null;
+                visitedTypedefs.add(fullName);
+                const inner = typeof typedef.type === 'string'
+                    ? this.resolveTypeToASTDefinition(typedef.type, currentNamespace, ast, visitedTypedefs)
+                    : null;
+                visitedTypedefs.delete(fullName);
+                return inner;
+            }
+        }
+        for (const s of ast.structs ?? []) {
+            if (this.getStructFullName(s, ast) === fullName)
+                return { kind: 'record', def: s };
+        }
+        for (const e of ast.enums ?? []) {
+            if (this.getEnumFullName(e, ast) === fullName)
+                return { kind: 'enum', def: e };
+        }
+        // AST에 정의되지 않은 타입 = 원시 타입 (휴리스틱 없음)
+        return { kind: 'primitive' };
+    }
+    /**
+     * Apache 호환: default 있는 struct 필드 할당 후, 그 내부의 default 있는 nested struct가 null이면 CreateDefault()로 채움.
+     * (기본값이 있는 중첩 필드는 AST 기준으로만 처리, 타입명 하드코딩 없음)
+     */
+    generateEnsureNestedDefaults(parentFieldName, fieldType, ast, currentNamespace) {
+        const target = this.findStruct(ast, fieldType, currentNamespace);
+        if (!target || !target.fields)
+            return [];
+        const targetNs = this.getStructNamespace(target, ast);
+        const out = [];
+        for (const nested of target.fields) {
+            if (nested.defaultValue === undefined)
+                continue;
+            const nestedCSharpType = this.getCSharpType(nested.type, ast, targetNs);
+            const isNestedStruct = typeof nested.type === 'string' && (this.isStructType(nested.type, ast, targetNs) ||
+                this.isStructCSharpType(nestedCSharpType, ast));
+            if (!isNestedStruct)
+                continue;
+            const nestedFieldName = this.capitalize(nested.name);
+            out.push(`if (this.${parentFieldName} != null && this.${parentFieldName}.${nestedFieldName} == null) this.${parentFieldName}.${nestedFieldName} = ${nestedCSharpType}.CreateDefault();`);
+        }
+        return out;
+    }
+    /** AST에서 풀네임으로만 struct 정의 찾기. typedef이면 대상 타입으로 따라감. */
+    findStruct(ast, typeName, currentNamespace) {
+        if (!ast || !ast.structs || typeof typeName !== 'string')
+            return null;
+        const fullName = this.resolveTypeToFullName(typeName, currentNamespace, ast);
+        for (const s of ast.structs) {
+            if (this.getStructFullName(s, ast) === fullName)
+                return s;
+        }
+        let typedef = this.findTypedef(ast, typeName, currentNamespace);
+        if (!typedef && typeName.includes('.')) {
+            const shortName = typeName.split('.').pop() ?? typeName;
+            typedef = this.findTypedef(ast, shortName, currentNamespace);
+        }
+        if (!typedef && ast.typedefs?.length) {
+            const shortName = typeName.includes('.') ? (typeName.split('.').pop() ?? typeName) : typeName;
+            for (const t of ast.typedefs) {
+                const tShort = t.name.includes('.') ? (t.name.split('.').pop() ?? t.name) : t.name;
+                if (tShort === shortName && typeof t.type === 'string') {
+                    typedef = t;
+                    break;
+                }
+            }
+        }
+        if (typedef && typeof typedef.type === 'string')
+            return this.findStruct(ast, typedef.type, currentNamespace);
+        return null;
+    }
+    /** AST에서 풀네임 또는 short name( currentNamespace 있을 때)으로 typedef 정의 찾기 */
+    findTypedef(ast, typeName, currentNamespace) {
+        if (!ast?.typedefs || typeof typeName !== 'string')
+            return null;
+        const fullName = this.resolveTypeToFullName(typeName, currentNamespace, ast);
+        for (const t of ast.typedefs) {
+            if (this.getTypedefFullName(t, ast) === fullName)
+                return t;
+        }
+        return null;
+    }
+    /**
+     * Struct 필드 기본값 객체 → C# 객체 초기화.
+     * Apache 호환: 특정 필드만 지정해도, 지정되지 않은 하위 struct 멤버는 CreateDefault()로 할당.
+     * 구조체·enum·변수 참조는 항상 풀네임으로 생성.
+     */
+    getCSharpStructObjectInitializer(defaultValue, fieldType, currentNamespace, ast) {
+        if (typeof defaultValue !== 'object' || defaultValue === null || Array.isArray(defaultValue)) {
+            return null;
+        }
+        const keys = Object.keys(defaultValue);
+        const typeName = typeof fieldType === 'string' ? fieldType : '';
+        const typeFullName = ast ? this.resolveTypeToFullName(typeName, currentNamespace, ast) : typeName;
+        const csharpType = this.getCSharpType(fieldType, ast, currentNamespace);
+        let targetStruct = this.findStruct(ast, typeFullName, currentNamespace);
+        if (!targetStruct && typeName && ast?.typedefs?.length) {
+            const shortName = typeFullName.includes('.') ? typeFullName.split('.').pop() : typeFullName;
+            for (const t of ast.typedefs) {
+                const tShort = t.name.includes('.') ? (t.name.split('.').pop() ?? t.name) : t.name;
+                if (tShort === shortName && typeof t.type === 'string') {
+                    targetStruct = this.findStruct(ast, t.type, currentNamespace);
+                    break;
+                }
+            }
+        }
+        if (!targetStruct && typeName) {
+            throw new Error(`[CSharpGenerator] Struct not found for default value object: ${typeFullName}`);
+        }
+        const assignments = [];
+        const assignedByPush = new Set();
+        for (const key of keys) {
+            const val = defaultValue[key];
+            const propName = this.capitalize(key);
+            const member = targetStruct?.fields?.find(f => f.name.toLowerCase() === key.toLowerCase());
+            if (!member && val !== null && val !== undefined) {
+                throw new Error(`[CSharpGenerator] Field '${key}' not found in struct ${csharpType} (default value)`);
+            }
+            const memberType = member?.type;
+            const memberTypeFull = (typeof memberType === 'string' && ast) ? this.resolveTypeToFullName(memberType, currentNamespace, ast) : memberType;
+            const rhs = this.getCSharpDefaultValueForStructMember(val, memberTypeFull, currentNamespace, ast, csharpType, key);
+            if (rhs !== null) {
+                assignments.push(`${propName} = ${rhs}`);
+                assignedByPush.add(key.toLowerCase());
+            }
+        }
+        if (targetStruct && ast) {
+            for (const member of targetStruct.fields) {
+                if (assignedByPush.has(member.name.toLowerCase()))
+                    continue;
+                if (typeof member.type !== 'string' || this.isEnumType(member.type, ast, currentNamespace))
+                    continue;
+                const isNestedStruct = this.isStructType(member.type, ast, currentNamespace) ||
+                    this.isStructCSharpType(this.getCSharpType(member.type, ast, currentNamespace), ast);
+                if (!isNestedStruct)
+                    continue;
+                const nestedType = this.getCSharpType(member.type, ast, currentNamespace);
+                assignments.push(`${this.capitalize(member.name)} = ${nestedType}.CreateDefault()`);
+            }
+        }
+        if (assignments.length === 0)
+            return null;
+        return `new ${csharpType}() { ${assignments.join(', ')} }`;
+    }
+    /**
+     * Struct 멤버 기본값 → C# 우변 식.
+     * enum/구조체/변수 참조는 항상 풀네임으로 생성. 필드 타입(풀네임)만 보고 분기.
+     */
+    getCSharpDefaultValueForStructMember(val, memberType, currentNamespace, ast, structName, fieldName) {
+        if (val === null || val === undefined)
+            return null;
+        const typeStr = typeof memberType === 'string' ? memberType : undefined;
+        if (typeStr === undefined) {
+            throw new Error(`[CSharpGenerator] Member type required for default value (struct: ${structName ?? '?'}, field: ${fieldName ?? '?'}). No fallback.`);
+        }
+        // 모든 타입 참조를 풀네임으로 통일 (구조체·enum 동일)
+        const typeFull = ast ? this.resolveTypeToFullName(typeStr, currentNamespace, ast) : typeStr;
+        const resolvedCSharpType = this.getCSharpType(memberType, ast, currentNamespace);
+        const isEnum = ast && this.isEnumTypeFullName(typeFull, ast, currentNamespace);
+        const isStruct = ast && this.isStructTypeFullName(typeFull, ast, currentNamespace);
+        const isNumeric = ['int', 'short', 'long', 'byte'].includes(resolvedCSharpType);
+        const quote = (s) => `"${String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+        switch (typeof val) {
+            case 'number':
+                if (isEnum) {
+                    throw new Error(`[CSharpGenerator] Enum field '${fieldName}' does not accept numeric default (struct: ${structName ?? '?'}).`);
+                }
+                if (resolvedCSharpType === 'bool')
+                    return val ? 'true' : 'false';
+                if (resolvedCSharpType === 'long' || typeStr === 'int64')
+                    return `${val}L`;
+                return `${val}`;
+            case 'boolean':
+                if (isNumeric)
+                    return val ? '1' : '0';
+                return val ? 'true' : 'false';
+            case 'object':
+                if (Array.isArray(val))
+                    return null;
+                if (!isStruct) {
+                    throw new Error(`[CSharpGenerator] Object default value for non-struct type '${typeFull}' (struct: ${structName ?? '?'}, field: ${fieldName ?? '?'}).`);
+                }
+                const nestedNs = typeFull.includes('.') ? typeFull.split('.').slice(0, -1).join('.') : currentNamespace;
+                const nested = this.getCSharpStructObjectInitializer(val, typeFull, nestedNs ?? currentNamespace, ast);
+                const csharpTypeName = this.getCSharpType(memberType, ast, currentNamespace);
+                return nested ?? `${csharpTypeName}.CreateDefault()`;
+            case 'string': {
+                const hasDot = val.includes('.') && val.split('.').length >= 2;
+                const valuePart = hasDot ? (val.split('.').pop() ?? val) : '';
+                // C# 생성물에 원시 타입명(i32 등)이 나오면 안 됨. 숫자 필드 enum 기본값은 항상 enum 풀네임으로 생성
+                const isPrimitive = ast && this.isPrimitiveSchemaType(typeFull, ast, currentNamespace);
+                let fullEnumExpr;
+                if (hasDot) {
+                    if (isPrimitive && ast) {
+                        const enumFull = this.findEnumFullNameByValueName(ast, valuePart, currentNamespace);
+                        if (!enumFull)
+                            throw new Error(`[CSharpGenerator] Cannot emit primitive in C#; no enum found for value '${valuePart}'. Struct: ${structName ?? '?'}, field: ${fieldName ?? '?'}.`);
+                        fullEnumExpr = `${enumFull}.${valuePart}`;
+                    }
+                    else {
+                        fullEnumExpr = `${typeFull}.${valuePart}`;
+                    }
+                }
+                else {
+                    fullEnumExpr = currentNamespace && val.split('.').length === 2 ? `${currentNamespace}.${val}` : val;
+                }
+                if (resolvedCSharpType === 'string')
+                    return quote(val);
+                if (resolvedCSharpType === 'bool' && (val === 'true' || val === 'false'))
+                    return val;
+                if (hasDot) {
+                    if (isEnum) {
+                        const enumDef = this.findEnumByFullName(ast ?? undefined, typeFull, currentNamespace);
+                        if (!enumDef || !Object.prototype.hasOwnProperty.call(enumDef.values, valuePart)) {
+                            throw new Error(`[CSharpGenerator] Enum '${typeFull}' has no value '${valuePart}' (struct: ${structName ?? '?'}, field: ${fieldName ?? '?'}).`);
+                        }
+                        return fullEnumExpr;
+                    }
+                    if (isNumeric) {
+                        if (!fullEnumExpr.includes('.')) {
+                            throw new Error(`[CSharpGenerator] Numeric field '${fieldName}' requires full enum reference (e.g. namespace.id_e.xxx), got: '${val}' (struct: ${structName ?? '?'}).`);
+                        }
+                        return `(int)${fullEnumExpr}`;
+                    }
+                    throw new Error(`[CSharpGenerator] Enum literal '${val}' but field type '${typeFull}' is not enum or numeric (struct: ${structName ?? '?'}, field: ${fieldName ?? '?'}).`);
+                }
+                if (isEnum) {
+                    throw new Error(`[CSharpGenerator] Enum field '${fieldName}' requires enum literal (e.g. id_e.xxx), got: '${val}' (struct: ${structName ?? '?'}).`);
+                }
+                if (isNumeric)
+                    return quote(val);
+                throw new Error(`[CSharpGenerator] String default value for type '${typeFull}' not supported (struct: ${structName ?? '?'}, field: ${fieldName ?? '?'}).`);
+            }
+            default:
+                throw new Error(`[CSharpGenerator] Unsupported default value type for '${typeFull}' (struct: ${structName ?? '?'}, field: ${fieldName ?? '?'}).`);
+        }
+    }
+    generateWriteCondition(field, fieldName, ast, currentNamespace) {
+        const explicitDefaultExpr = field.defaultValue !== undefined && ast
+            ? this.getCSharpDefaultValue(field.defaultValue, field.type, ast, currentNamespace)
+            : null;
+        // tablelink is always long (value type)
+        if (typeof field.type === 'object' && field.type !== null && field.type.type === 'tablelink') {
+            return `if (this.${fieldName} != 0L)  // tablelink is long, never null`;
+        }
+        if (typeof field.type === 'string') {
+            const primitiveTypes = ['bool', 'byte', 'int8', 'int16', 'int32', 'int64', 'float', 'double'];
+            if (primitiveTypes.includes(field.type)) {
+                if (explicitDefaultExpr !== null && explicitDefaultExpr !== 'null') {
+                    const longSuffix = (field.type === 'int64' && /^\d+$/.test(explicitDefaultExpr)) ? 'L' : '';
+                    return `if (this.${fieldName} != ${explicitDefaultExpr}${longSuffix})  // skip when equals default`;
+                }
+                switch (field.type) {
+                    case 'bool':
+                        return `if (this.${fieldName})  // bool is never null, check if true`;
+                    case 'byte':
+                    case 'int8':
+                        return `if (this.${fieldName} != 0)  // byte is never null, check if non-zero`;
+                    case 'int16':
+                        return `if (this.${fieldName} != 0)  // short is never null, check if non-zero`;
+                    case 'int32':
+                        return `if (this.${fieldName} != 0)  // int is never null, check if non-zero`;
+                    case 'int64':
+                        return `if (this.${fieldName} != 0L)  // long is never null, check if non-zero`;
+                    case 'float':
+                    case 'double':
+                        return `if (this.${fieldName} != 0.0)  // double is never null, check if non-zero`;
+                    default:
+                        return `if (this.${fieldName} != null)`;
+                }
+            }
+            if (ast && this.isEnumType(field.type, ast, currentNamespace)) {
+                if (explicitDefaultExpr !== null && explicitDefaultExpr !== 'null') {
+                    return `if (this.${fieldName} != ${explicitDefaultExpr})  // skip when equals default`;
+                }
+                return `if (true)  // enum is never null, always write`;
+            }
+            if (ast) {
+                const resolvedType = this.getCSharpType(field.type, ast, currentNamespace);
+                const valueTypeConditions = [
+                    ['long', 'if (this.${fieldName} != 0L)  // long (typedef) is never null'],
+                    ['int', 'if (this.${fieldName} != 0)  // int (typedef) is never null'],
+                    ['short', 'if (this.${fieldName} != 0)  // short (typedef) is never null'],
+                    ['byte', 'if (this.${fieldName} != 0)  // byte (typedef) is never null'],
+                    ['bool', 'if (this.${fieldName})  // bool (typedef) is never null'],
+                    ['double', 'if (this.${fieldName} != 0.0)  // double (typedef) is never null'],
+                    ['float', 'if (this.${fieldName} != 0f)  // float (typedef) is never null'],
+                    ['Single', 'if (this.${fieldName} != 0f)  // float (typedef) is never null'],
+                    ['DateTime', 'if (this.${fieldName} != default(DateTime))  // datetime (typedef)'],
+                    ['TimeSpan', 'if (this.${fieldName} != default(TimeSpan))  // time (typedef)'],
+                    ['decimal', 'if (this.${fieldName} != 0m)  // decimal (typedef) is never null'],
+                ];
+                for (const [t, cond] of valueTypeConditions) {
+                    if (resolvedType === t)
+                        return cond.replace('${fieldName}', fieldName);
+                }
+            }
+            if (field.type === 'string') {
+                if (explicitDefaultExpr !== null) {
+                    // default "" 등: null이 아니고 기본값이 아닐 때만 Write
+                    return `if (this.${fieldName} != null && this.${fieldName} != ${explicitDefaultExpr})  // skip when null or default`;
+                }
+                return `if (this.${fieldName} != null)`;
+            }
+            // typedef로 정의된 primitive 타입인지 확인
+            if (ast && this.isPrimitiveType(field.type, ast, currentNamespace)) {
+                if (explicitDefaultExpr !== null && explicitDefaultExpr !== 'null') {
+                    const resolvedType = this.getCSharpType(field.type, ast, currentNamespace);
+                    const longSuffix = (resolvedType === 'long' && /^\d+$/.test(explicitDefaultExpr)) ? 'L' : '';
+                    return `if (this.${fieldName} != ${explicitDefaultExpr}${longSuffix})  // skip when equals default`;
+                }
+                const resolvedType = this.getCSharpType(field.type, ast, currentNamespace);
+                if (resolvedType === 'long') {
+                    return `if (this.${fieldName} != 0L)  // long is never null, check if non-zero`;
+                }
+                if (resolvedType === 'int') {
+                    return `if (this.${fieldName} != 0)  // int is never null, check if non-zero`;
+                }
+                if (resolvedType === 'double') {
+                    return `if (this.${fieldName} != 0.0)  // double is never null, check if non-zero`;
+                }
+                if (resolvedType === 'DateTime') {
+                    return `if (this.${fieldName} != default(DateTime))  // datetime/date/timestamp`;
+                }
+                if (resolvedType === 'TimeSpan') {
+                    return `if (this.${fieldName} != default(TimeSpan))  // time`;
+                }
+                if (resolvedType === 'decimal') {
+                    return `if (this.${fieldName} != 0m)  // decimal/numeric`;
+                }
+            }
+            // struct 타입도 nullable이 아니지만, null 체크 필요 (reference type)
+            return `if (this.${fieldName} != null)`;
+        }
+        // reference 타입 (struct, list, set, map 등)은 null 체크
+        return `if (this.${fieldName} != null)`;
+    }
+    /** 레거시 Thrift typedef i64 _link_* / _linktid_* 타입명 여부 (AST에 typedef 없을 때 long 처리용). */
+    isLinkTypedefName(typeName) {
+        return typeof typeName === 'string' && (typeName.startsWith('_link_') || typeName.startsWith('_linktid_'));
+    }
+    /** currentNamespace 지정 시 다른 네임스페이스 타입은 풀네임으로 반환. AST 조회만 사용(휴리스틱 없음). */
+    getCSharpType(type, ast, currentNamespace) {
+        if (typeof type === 'string') {
+            switch (type) {
+                case 'bool': return 'bool';
+                case 'byte': return 'byte';
+                case 'int8': return 'sbyte';
+                case 'int16': return 'short';
+                case 'int32': return 'int';
+                case 'int64': return 'long';
+                case 'float': return 'float';
+                case 'double': return 'double';
+                case 'string': return 'string';
+                case 'binary': return 'byte[]';
+                case 'datetime':
+                case 'timestamp':
+                case 'date': return 'DateTime';
+                case 'time': return 'TimeSpan';
+                case 'decimal':
+                case 'numeric': return 'decimal';
+                default: {
+                    const primitives = ['bool', 'byte', 'int8', 'int16', 'int32', 'int64', 'float', 'double', 'string', 'binary', 'datetime', 'timestamp', 'date', 'time', 'decimal', 'numeric'];
+                    const typedefDef = ast ? this.findTypedef(ast, type, currentNamespace) : null;
+                    if (typedefDef)
+                        return this.getCSharpType(typedefDef.type, ast, currentNamespace);
+                    // 레거시 Thrift typedef i64 _link_* / _linktid_*: AST에 typedef 없을 때 long으로 처리 (코드젠/마이그레이터 호환)
+                    if (this.isLinkTypedefName(type))
+                        return 'long';
+                    const fullName = ast ? this.resolveTypeToFullName(type, currentNamespace, ast) : type;
+                    if (primitives.includes(fullName)) {
+                        return this.getCSharpType(fullName, ast, currentNamespace);
+                    }
+                    return fullName;
+                }
+            }
+        }
+        if (typeof type === 'object' && type.type) {
+            switch (type.type) {
+                case 'list':
+                    return `List<${this.getCSharpType(type.elementType, ast, currentNamespace)}>`;
+                case 'set':
+                    return `HashSet<${this.getCSharpType(type.elementType, ast, currentNamespace)}>`;
+                case 'map':
+                    return `Dictionary<${this.getCSharpType(type.keyType, ast, currentNamespace)}, ${this.getCSharpType(type.valueType, ast, currentNamespace)}>`;
+                case 'tablelink':
+                    return 'long';
+                default:
+                    return 'object';
+            }
+        }
+        return 'object';
+    }
+    getCSharpDefaultValue(value, type, ast, currentNamespace) {
+        // 숫자 값이 list/set/map 타입에 할당된 경우 (잘못된 IDL 정의)
+        if (typeof value === 'number' && typeof type === 'object' && type !== null && type.type) {
+            switch (type.type) {
+                case 'list':
+                    const listElemType = this.getCSharpType(type.elementType, ast, currentNamespace);
+                    return `new List<${listElemType}>()`;
+                case 'set':
+                    const setElemType = this.getCSharpType(type.elementType, ast, currentNamespace);
+                    return `new HashSet<${setElemType}>()`;
+                case 'map':
+                    const keyType = this.getCSharpType(type.keyType, ast, currentNamespace);
+                    const valueType = this.getCSharpType(type.valueType, ast, currentNamespace);
+                    return `new Dictionary<${keyType}, ${valueType}>()`;
+            }
+        }
+        if (typeof value === 'string') {
+            // enum 값인지 확인 (예: community_type_e.None, mo_define.level_exp_type_e.None)
+            if (value.includes('.')) {
+                const parts = value.split('.');
+                const possibleEnumName = parts.length >= 2 ? parts.slice(0, -1).join('.') : '';
+                const valuePart = parts.length >= 2 ? (parts[parts.length - 1] ?? '') : '';
+                if (parts.length >= 2) {
+                    // AST에서 enum 찾기 → 항상 풀네임으로 출력
+                    if (ast && this.isEnumType(possibleEnumName, ast, currentNamespace)) {
+                        const enumDef = this.findEnumByFullName(ast, possibleEnumName, currentNamespace);
+                        if (enumDef)
+                            return `${this.getEnumFullName(enumDef, ast)}.${valuePart}`;
+                        return value;
+                    }
+                    // 접두어가 원시 타입(i32 등)이면 C# 생성물에 나오면 안 됨 → 값 이름으로 enum 풀네임 조회 후 반환
+                    if (ast && valuePart && this.isPrimitiveSchemaType(possibleEnumName, ast, currentNamespace)) {
+                        const enumFull = this.findEnumFullNameByValueName(ast, valuePart, currentNamespace);
+                        if (enumFull)
+                            return `${enumFull}.${valuePart}`;
+                    }
+                }
+                // version.app_version 같은 상수 참조인지 확인
+                if (ast) {
+                    const resolved = this.resolveConstant(value, ast);
+                    if (resolved !== null) {
+                        return String(resolved);
+                    }
+                }
+                // 접두어가 타입(enum/struct)이면 풀네임으로 해석 후 반환
+                if (ast && possibleEnumName && valuePart) {
+                    const prefixFull = this.resolveTypeToFullName(possibleEnumName, currentNamespace, ast);
+                    if (prefixFull && prefixFull !== possibleEnumName)
+                        return `${prefixFull}.${valuePart}`;
+                }
+                return value;
+            }
+            // Check if it's a boolean string
+            if (value === 'true' || value === 'false') {
+                return value;
+            }
+            return `"${value}"`;
+        }
+        if (typeof value === 'number') {
+            return value.toString();
+        }
+        if (typeof value === 'boolean') {
+            return value ? 'true' : 'false';
+        }
+        // null, undefined 또는 타입만 있고 값이 없는 경우
+        if (value === null || value === undefined || typeof value === 'object') {
+            // {} 등 빈 객체 + struct 타입: 하위 모든 구조체가 할당되도록 CreateDefault() 사용
+            if (typeof type === 'string' && ast && this.isStructType(type, ast, currentNamespace)) {
+                const csharpType = this.getCSharpType(type, ast, currentNamespace);
+                return `${csharpType}.CreateDefault()`;
+            }
+            // 타입에 따른 기본값 설정
+            if (typeof type === 'object' && type !== null && type.type) {
+                switch (type.type) {
+                    case 'list':
+                        const listElemType2 = this.getCSharpType(type.elementType, ast, currentNamespace);
+                        return `new List<${listElemType2}>()`;
+                    case 'set':
+                        const setElemType2 = this.getCSharpType(type.elementType, ast, currentNamespace);
+                        return `new HashSet<${setElemType2}>()`;
+                    case 'map':
+                        const keyType2 = this.getCSharpType(type.keyType, ast, currentNamespace);
+                        const valueType2 = this.getCSharpType(type.valueType, ast, currentNamespace);
+                        return `new Dictionary<${keyType2}, ${valueType2}>()`;
+                    case 'tablelink':
+                        return '0L';
+                    default:
+                        return 'null';
+                }
+            }
+            if (typeof type === 'string') {
+                switch (type) {
+                    case 'bool': return 'false';
+                    case 'byte':
+                    case 'int8':
+                    case 'int16':
+                    case 'int32':
+                    case 'int64':
+                    case 'float':
+                    case 'double': return type === 'int64' ? '0L' : '0';
+                    case 'string': return '""';
+                    case 'datetime':
+                    case 'timestamp':
+                    case 'date': return 'default(DateTime)';
+                    case 'time': return 'default(TimeSpan)';
+                    case 'decimal':
+                    case 'numeric': return '0m';
+                    default:
+                        // enum이면 첫 번째 값 또는 기본값 (AST 조회)
+                        const enumResolved = ast ? this.resolveTypeToASTDefinition(type, currentNamespace, ast) : null;
+                        if (enumResolved?.kind === 'enum' && ast && enumResolved.def.values && typeof enumResolved.def.values === 'object') {
+                            const entries = Object.entries(enumResolved.def.values);
+                            const firstEntry = entries[0];
+                            if (firstEntry) {
+                                const enumFullName = this.getEnumFullName(enumResolved.def, ast);
+                                return `${enumFullName}.${firstEntry[0]}`;
+                            }
+                        }
+                        return 'null';
+                }
+            }
+            return 'null';
+        }
+        return 'null';
+    }
+    capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+    /** typedef를 따라 최종 wire 타입 문자열 반환 (타입 매칭용). 객체(list/set/map)는 그대로 두고 getTType에서 처리. */
+    getResolvedWireTypeString(type, ast, currentNamespace) {
+        if (typeof type !== 'string')
+            return typeof type === 'object' && type?.type ? type.type : 'record';
+        const typedefDef = ast ? this.findTypedef(ast, type, currentNamespace) : null;
+        if (typedefDef) {
+            const inner = typedefDef.type;
+            if (typeof inner === 'string')
+                return this.getResolvedWireTypeString(inner, ast, currentNamespace);
+        }
+        if (this.isLinkTypedefName(type))
+            return 'int64';
+        return type;
+    }
+    /** Wire type: enum→I32, typedef→해당 primitive/enum/struct/list/set/map, 그 외 custom→Struct. */
+    getTType(type, ast, currentNamespace) {
+        if (typeof type === 'string') {
+            const typedefDef = ast ? this.findTypedef(ast, type, currentNamespace) : null;
+            if (typedefDef && typeof typedefDef.type !== 'string')
+                return this.getTType(typedefDef.type, ast, currentNamespace);
+            const resolved = ast ? this.getResolvedWireTypeString(type, ast, currentNamespace) : type;
+            switch (resolved) {
+                case 'bool': return 'DpWireType.Bool';
+                case 'byte': return 'DpWireType.Byte';
+                case 'int8': return 'DpWireType.Byte';
+                case 'int16': return 'DpWireType.I16';
+                case 'int32': return 'DpWireType.I32';
+                case 'int64': return 'DpWireType.I64';
+                case 'float':
+                case 'double': return 'DpWireType.Double';
+                case 'string': return 'DpWireType.String';
+                case 'binary': return 'DpWireType.String';
+                case 'datetime':
+                case 'timestamp': return 'DpWireType.I64';
+                case 'date':
+                case 'time': return 'DpWireType.I32';
+                case 'decimal':
+                case 'numeric': return 'DpWireType.String';
+                default:
+                    if (this.isLinkTypedefName(resolved))
+                        return 'DpWireType.I64';
+                    if (ast && this.resolveTypeToASTDefinition(resolved, currentNamespace, ast)?.kind === 'enum')
+                        return 'DpWireType.I32';
+                    return 'DpWireType.Struct';
+            }
+        }
+        if (typeof type === 'object' && type.type) {
+            switch (type.type) {
+                case 'list': return 'DpWireType.List';
+                case 'set': return 'DpWireType.Set';
+                case 'map': return 'DpWireType.Map';
+                case 'tablelink': return 'DpWireType.I64';
+                default: return 'DpWireType.Struct';
+            }
+        }
+        return 'DpWireType.Struct';
+    }
+    generateWriteField(field, ast, currentNamespace) {
+        const fieldName = this.capitalize(field.name);
+        const tType = this.getTType(field.type, ast, currentNamespace);
+        if (typeof field.type === 'string') {
+            switch (field.type) {
+                case 'bool': return `DeukPackSerializer.WriteValue(oprot, ${tType}, this.${fieldName});`;
+                case 'byte':
+                case 'int8':
+                case 'int16':
+                case 'int32':
+                case 'int64':
+                case 'float':
+                case 'double': return `DeukPackSerializer.WriteValue(oprot, ${tType}, this.${fieldName});`;
+                case 'string': return `DeukPackSerializer.WriteValue(oprot, ${tType}, this.${fieldName});`;
+                case 'binary': return `DeukPackSerializer.WriteValue(oprot, ${tType}, this.${fieldName});`;
+                case 'datetime':
+                case 'timestamp': return `DeukPackSerializer.WriteValue(oprot, DpWireType.I64, this.${fieldName}.Ticks);`;
+                case 'date': return `DeukPackSerializer.WriteValue(oprot, DpWireType.I32, this.${fieldName}.Year * 10000 + this.${fieldName}.Month * 100 + this.${fieldName}.Day);`;
+                case 'time': return `DeukPackSerializer.WriteValue(oprot, DpWireType.I32, (int)this.${fieldName}.TotalMilliseconds);`;
+                case 'decimal':
+                case 'numeric': return `DeukPackSerializer.WriteValue(oprot, DpWireType.String, this.${fieldName}.ToString(System.Globalization.CultureInfo.InvariantCulture));`;
+                default: return `DeukPackSerializer.WriteValue(oprot, ${tType}, this.${fieldName});`; // Recursive for custom types
+            }
+        }
+        if (typeof field.type === 'object' && 'type' in field.type) {
+            switch (field.type.type) {
+                case 'list': return this.generateWriteList(field, ast, currentNamespace);
+                case 'set': return this.generateWriteSet(field, ast, currentNamespace);
+                case 'map': return this.generateWriteMap(field, ast, currentNamespace);
+                default: return `DeukPackSerializer.WriteValue(oprot, ${tType}, this.${fieldName});`;
+            }
+        }
+        return `DeukPackSerializer.WriteValue(oprot, ${tType}, this.${fieldName});`;
+    }
+    generateReadField(field, ast, currentNamespace) {
+        const fieldName = this.capitalize(field.name);
+        const tType = this.getTType(field.type, ast, currentNamespace);
+        const csharpType = this.getCSharpType(field.type, ast, currentNamespace);
+        if (typeof field.type === 'string') {
+            switch (field.type) {
+                case 'bool': return `this.${fieldName} = (bool)DeukPackSerializer.ReadValue(iprot, ${tType}, typeof(bool));`;
+                case 'byte': return `this.${fieldName} = (byte)DeukPackSerializer.ReadValue(iprot, ${tType}, typeof(byte));`;
+                case 'int8': return `this.${fieldName} = (sbyte)DeukPackSerializer.ReadValue(iprot, ${tType}, typeof(sbyte));`;
+                case 'int16': return `this.${fieldName} = (short)DeukPackSerializer.ReadValue(iprot, ${tType}, typeof(short));`;
+                case 'int32': return `this.${fieldName} = (int)DeukPackSerializer.ReadValue(iprot, ${tType}, typeof(int));`;
+                case 'int64': return `this.${fieldName} = (long)DeukPackSerializer.ReadValue(iprot, ${tType}, typeof(long));`;
+                case 'float': return `this.${fieldName} = (float)DeukPackSerializer.ReadValue(iprot, ${tType}, typeof(float));`;
+                case 'double': return `this.${fieldName} = (double)DeukPackSerializer.ReadValue(iprot, ${tType}, typeof(double));`;
+                case 'string': return `this.${fieldName} = (string)DeukPackSerializer.ReadValue(iprot, ${tType}, typeof(string));`;
+                case 'binary': return `this.${fieldName} = (byte[])DeukPackSerializer.ReadValue(iprot, ${tType}, typeof(byte[]));`;
+                case 'datetime':
+                case 'timestamp': return `this.${fieldName} = new DateTime((long)DeukPackSerializer.ReadValue(iprot, DpWireType.I64, typeof(long)), DateTimeKind.Utc);`;
+                case 'date': {
+                    const v = `(int)DeukPackSerializer.ReadValue(iprot, DpWireType.I32, typeof(int))`;
+                    return `var _${fieldName} = ${v}; this.${fieldName} = _${fieldName} == 0 ? default(DateTime) : new DateTime(_${fieldName} / 10000, (_${fieldName} / 100) % 100, _${fieldName} % 100);`;
+                }
+                case 'time': return `this.${fieldName} = TimeSpan.FromMilliseconds((int)DeukPackSerializer.ReadValue(iprot, DpWireType.I32, typeof(int)));`;
+                case 'decimal':
+                case 'numeric': return `var _${fieldName}Str = (string)DeukPackSerializer.ReadValue(iprot, DpWireType.String, typeof(string)); this.${fieldName} = string.IsNullOrEmpty(_${fieldName}Str) ? 0m : decimal.Parse(_${fieldName}Str, System.Globalization.CultureInfo.InvariantCulture);`;
+                default: {
+                    const readExpr = `(${csharpType})DeukPackSerializer.ReadValue(iprot, ${tType}, typeof(${csharpType}))`;
+                    const isStruct = ast && (this.isStructType(field.type, ast, currentNamespace) || this.isStructCSharpType(csharpType, ast));
+                    return isStruct ? `this.${fieldName} = ${readExpr} ?? ${csharpType}.CreateDefault();` : `this.${fieldName} = ${readExpr};`;
+                }
+            }
+        }
+        if (typeof field.type === 'object' && 'type' in field.type) {
+            switch (field.type.type) {
+                case 'list': return this.generateReadList(field, ast, currentNamespace);
+                case 'set': return this.generateReadSet(field, ast, currentNamespace);
+                case 'map': return this.generateReadMap(field, ast, currentNamespace);
+                default: {
+                    const readExpr = `(${csharpType})DeukPackSerializer.ReadValue(iprot, ${tType}, typeof(${csharpType}))`;
+                    const isStruct = ast && this.isStructCSharpType(csharpType, ast);
+                    return isStruct ? `this.${fieldName} = ${readExpr} ?? ${csharpType}.CreateDefault();` : `this.${fieldName} = ${readExpr};`;
+                }
+            }
+        }
+        const readExpr = `(${csharpType})DeukPackSerializer.ReadValue(iprot, ${tType}, typeof(${csharpType}))`;
+        const isStruct = ast && (this.isStructType(field.type, ast, currentNamespace) || this.isStructCSharpType(csharpType, ast));
+        return isStruct ? `this.${fieldName} = ${readExpr} ?? ${csharpType}.CreateDefault();` : `this.${fieldName} = ${readExpr};`;
+    }
+    generateWriteList(field, ast, currentNamespace) {
+        const fieldName = this.capitalize(field.name);
+        if (typeof field.type === 'object' && 'type' in field.type && field.type.type === 'list') {
+            const elementType = this.getTType(field.type.elementType, ast, currentNamespace);
+            const csharpElementType = this.getCSharpType(field.type.elementType, ast, currentNamespace);
+            return `DeukPackSerializer.WriteList<${csharpElementType}>(oprot, ${elementType}, this.${fieldName});`;
+        }
+        return `DeukPackSerializer.WriteValue(oprot, DpWireType.List, this.${fieldName});`;
+    }
+    generateWriteSet(field, ast, currentNamespace) {
+        const fieldName = this.capitalize(field.name);
+        if (typeof field.type === 'object' && 'type' in field.type && field.type.type === 'set') {
+            const elementType = this.getTType(field.type.elementType, ast, currentNamespace);
+            const csharpElementType = this.getCSharpType(field.type.elementType, ast, currentNamespace);
+            return `DeukPackSerializer.WriteSet<${csharpElementType}>(oprot, ${elementType}, this.${fieldName});`;
+        }
+        return `DeukPackSerializer.WriteValue(oprot, DpWireType.Set, this.${fieldName});`;
+    }
+    generateWriteMap(field, ast, currentNamespace) {
+        const fieldName = this.capitalize(field.name);
+        if (typeof field.type === 'object' && 'type' in field.type && field.type.type === 'map') {
+            const keyType = this.getTType(field.type.keyType, ast, currentNamespace);
+            const valueType = this.getTType(field.type.valueType, ast, currentNamespace);
+            const csharpKeyType = this.getCSharpType(field.type.keyType, ast, currentNamespace);
+            const csharpValueType = this.getCSharpType(field.type.valueType, ast, currentNamespace);
+            return `DeukPackSerializer.WriteMap<${csharpKeyType}, ${csharpValueType}>(oprot, ${keyType}, ${valueType}, this.${fieldName});`;
+        }
+        return `DeukPackSerializer.WriteValue(oprot, DpWireType.Map, this.${fieldName});`;
+    }
+    // generateWriteListElement is no longer needed - handled by DeukPackSerializer recursively
+    generateReadList(field, ast, currentNamespace) {
+        const fieldName = this.capitalize(field.name);
+        if (typeof field.type === 'object' && 'type' in field.type && field.type.type === 'list') {
+            const elementType = this.getTType(field.type.elementType, ast, currentNamespace);
+            const csharpElementType = this.getCSharpType(field.type.elementType, ast, currentNamespace);
+            return `this.${fieldName} = DeukPackSerializer.ReadList<${csharpElementType}>(iprot, ${elementType});`;
+        }
+        const csharpType = this.getCSharpType(field.type, ast, currentNamespace);
+        return `this.${fieldName} = (${csharpType})DeukPackSerializer.ReadValue(iprot, DpWireType.List, typeof(${csharpType}));`;
+    }
+    generateReadSet(field, ast, currentNamespace) {
+        const fieldName = this.capitalize(field.name);
+        if (typeof field.type === 'object' && 'type' in field.type && field.type.type === 'set') {
+            const elementType = this.getTType(field.type.elementType, ast, currentNamespace);
+            const csharpElementType = this.getCSharpType(field.type.elementType, ast, currentNamespace);
+            return `this.${fieldName} = DeukPackSerializer.ReadSet<${csharpElementType}>(iprot, ${elementType});`;
+        }
+        const csharpType = this.getCSharpType(field.type, ast, currentNamespace);
+        return `this.${fieldName} = (${csharpType})DeukPackSerializer.ReadValue(iprot, DpWireType.Set, typeof(${csharpType}));`;
+    }
+    generateReadMap(field, ast, currentNamespace) {
+        const fieldName = this.capitalize(field.name);
+        if (typeof field.type === 'object' && 'type' in field.type && field.type.type === 'map') {
+            const keyType = this.getTType(field.type.keyType, ast, currentNamespace);
+            const valueType = this.getTType(field.type.valueType, ast, currentNamespace);
+            const csharpKeyType = this.getCSharpType(field.type.keyType, ast, currentNamespace);
+            const csharpValueType = this.getCSharpType(field.type.valueType, ast, currentNamespace);
+            return `this.${fieldName} = DeukPackSerializer.ReadMap<${csharpKeyType}, ${csharpValueType}>(iprot, ${keyType}, ${valueType});`;
+        }
+        const csharpType = this.getCSharpType(field.type, ast, currentNamespace);
+        return `this.${fieldName} = (${csharpType})DeukPackSerializer.ReadValue(iprot, DpWireType.Map, typeof(${csharpType}));`;
+    }
+    // generateReadListElement is no longer needed - handled by DeukPackSerializer recursively
+    groupByNamespace(ast) {
+        const groups = {};
+        const namespaces = ast.namespaces.map(ns => ns.name);
+        if (namespaces.length === 0) {
+            namespaces.push('Generated');
+        }
+        for (const ns of namespaces) {
+            groups[ns] = { enums: [], structs: [], typedefs: [], constants: [], services: [] };
+        }
+        for (const enumDef of ast.enums) {
+            const ns = this.getEnumNamespace(enumDef, ast);
+            if (groups[ns])
+                groups[ns].enums.push(enumDef);
+        }
+        for (const struct of ast.structs) {
+            const ns = this.getStructNamespace(struct, ast);
+            if (groups[ns])
+                groups[ns].structs.push(struct);
+        }
+        for (const typedef of ast.typedefs) {
+            const ns = this.getTypedefNamespace(typedef, ast);
+            if (groups[ns])
+                groups[ns].typedefs.push(typedef);
+        }
+        for (const constant of ast.constants) {
+            const ns = this.getConstantNamespace(constant, ast);
+            if (groups[ns])
+                groups[ns].constants.push(constant);
+        }
+        for (const service of ast.services || []) {
+            const ns = this.getServiceNamespace(service, ast);
+            if (groups[ns])
+                groups[ns].services.push(service);
+        }
+        return groups;
+    }
+    getServiceNamespace(service, ast) {
+        const mapped = service.sourceFile && ast.fileNamespaceMap ? ast.fileNamespaceMap[service.sourceFile] : undefined;
+        if (mapped)
+            return mapped;
+        if (service.sourceFile) {
+            const ns = ast.namespaces.find(n => (n.language === '*' || n.language === 'csharp') && n.sourceFile === service.sourceFile);
+            if (ns && ns.name)
+                return ns.name;
+        }
+        const def = ast.namespaces.find(n => n.language === '*' || n.language === 'csharp');
+        return (def && def.name) ? def.name : 'Generated';
+    }
+    generateService(service, ast, namespace) {
+        const lines = [];
+        const opts = this._genOptions;
+        lines.push(`  /// <summary>Thrift service: ${service.name}</summary>`);
+        lines.push(`  public interface I${service.name}`);
+        lines.push('  {');
+        for (const method of service.methods) {
+            const retCs = this.getCSharpType(method.returnType, ast, namespace);
+            const params = (method.parameters || []).map(p => `${this.getCSharpType(p.type, ast, namespace)} ${p.name}`).join(', ');
+            lines.push(`    ${retCs} ${method.name}(${params});`);
+        }
+        lines.push('  }');
+        lines.push('');
+        lines.push(`  public static partial class ${service.name}`);
+        lines.push('  {');
+        for (const method of service.methods) {
+            const retCs = this.getCSharpType(method.returnType, ast, namespace);
+            const params = (method.parameters || []).map(p => `${this.getCSharpType(p.type, ast, namespace)} ${p.name}`).join(', ');
+            if (service.name === 'ThriftDefineService' && method.name === 'GetDefineVersion') {
+                let versionValue = '"unknown"';
+                if (opts?.defineVersionFile) {
+                    try {
+                        const content = fs.readFileSync(path.resolve(opts.defineVersionFile), 'utf-8').trim();
+                        versionValue = JSON.stringify(content);
+                    }
+                    catch {
+                        versionValue = '"unknown"';
+                    }
+                }
+                lines.push(`    public static ${retCs} ${method.name}(${params}) => ${versionValue};`);
+            }
+            else {
+                lines.push(`    public static ${retCs} ${method.name}(${params}) => default;`);
+            }
+        }
+        lines.push('  }');
+        return lines;
+    }
+    getEnumNamespace(enumDef, ast) {
+        // 파일 경로 기반으로 네임스페이스 찾기
+        if (enumDef.sourceFile && ast.fileNamespaceMap) {
+            const namespace = ast.fileNamespaceMap[enumDef.sourceFile];
+            if (namespace) {
+                return namespace;
+            }
+        }
+        // Enum의 sourceFile과 같은 파일의 네임스페이스 찾기
+        if (enumDef.sourceFile) {
+            const namespace = ast.namespaces.find(ns => (ns.language === '*' || ns.language === 'csharp') &&
+                ns.sourceFile === enumDef.sourceFile);
+            if (namespace) {
+                return namespace.name;
+            }
+        }
+        // Fallback: 첫 번째 네임스페이스 또는 'Generated'
+        const namespace = ast.namespaces.find(ns => ns.language === '*' || ns.language === 'csharp');
+        return namespace ? namespace.name : 'Generated';
+    }
+    getStructNamespace(struct, ast) {
+        // 파일 경로 기반으로 네임스페이스 찾기
+        if (struct.sourceFile && ast.fileNamespaceMap) {
+            const namespace = ast.fileNamespaceMap[struct.sourceFile];
+            if (namespace) {
+                return namespace;
+            }
+        }
+        // 구조체의 sourceFile과 같은 파일의 네임스페이스 찾기
+        if (struct.sourceFile) {
+            const namespace = ast.namespaces.find(ns => (ns.language === '*' || ns.language === 'csharp') &&
+                ns.sourceFile === struct.sourceFile);
+            if (namespace) {
+                return namespace.name;
+            }
+        }
+        // Fallback: 첫 번째 네임스페이스 또는 'Generated'
+        const namespace = ast.namespaces.find(ns => ns.language === '*' || ns.language === 'csharp');
+        return namespace ? namespace.name : 'Generated';
+    }
+    getTypedefNamespace(typedef, ast) {
+        const norm = (p) => p.replace(/\\/g, '/');
+        if (typedef.sourceFile && ast.fileNamespaceMap) {
+            const key = ast.fileNamespaceMap[typedef.sourceFile];
+            if (key)
+                return key;
+            const normalized = norm(typedef.sourceFile);
+            const entry = Object.entries(ast.fileNamespaceMap).find(([k]) => norm(k) === normalized);
+            if (entry)
+                return entry[1];
+        }
+        if (typedef.sourceFile) {
+            const ns = ast.namespaces.find(ns => (ns.language === '*' || ns.language === 'csharp') &&
+                ns.sourceFile && norm(ns.sourceFile) === norm(typedef.sourceFile));
+            if (ns)
+                return ns.name;
+        }
+        // Fallback: 첫 번째 네임스페이스 또는 'Generated'
+        const namespace = ast.namespaces.find(ns => ns.language === '*' || ns.language === 'csharp');
+        return namespace ? namespace.name : 'Generated';
+    }
+    getConstantNamespace(constant, ast) {
+        // 파일 경로 기반으로 네임스페이스 찾기
+        if (constant.sourceFile && ast.fileNamespaceMap) {
+            const namespace = ast.fileNamespaceMap[constant.sourceFile];
+            if (namespace) {
+                return namespace;
+            }
+        }
+        // Constant의 sourceFile과 같은 파일의 네임스페이스 찾기
+        if (constant.sourceFile) {
+            const namespace = ast.namespaces.find(ns => (ns.language === '*' || ns.language === 'csharp') &&
+                ns.sourceFile === constant.sourceFile);
+            if (namespace) {
+                return namespace.name;
+            }
+        }
+        // Fallback: 첫 번째 네임스페이스 또는 'Generated'
+        const namespace = ast.namespaces.find(ns => ns.language === '*' || ns.language === 'csharp');
+        return namespace ? namespace.name : 'Generated';
+    }
+    /** AST 조회로만 판별. currentNamespace 있으면 short name 해석. */
+    isPrimitiveType(type, ast, currentNamespace) {
+        return this.resolveTypeToASTDefinition(type, currentNamespace, ast)?.kind === 'primitive';
+    }
+    /** AST 조회로만 판별 (휴리스틱 없음). currentNamespace 있으면 short name 해석. */
+    isEnumType(type, ast, currentNamespace) {
+        return this.resolveTypeToASTDefinition(type, currentNamespace, ast)?.kind === 'enum';
+    }
+    /** AST 조회로만 판별. currentNamespace 있으면 short name 해석. */
+    isEnumTypeFullName(typeStr, ast, currentNamespace) {
+        return this.resolveTypeToASTDefinition(typeStr, currentNamespace, ast)?.kind === 'enum';
+    }
+    /** 풀네임 또는 short name( currentNamespace 있을 때)으로 enum 정의 반환 */
+    findEnumByFullName(ast, typeStr, currentNamespace) {
+        if (!ast?.enums || !typeStr)
+            return null;
+        const fullName = currentNamespace !== undefined ? this.resolveTypeToFullName(typeStr, currentNamespace, ast) : typeStr;
+        for (const enumDef of ast.enums) {
+            if (this.getEnumFullName(enumDef, ast) === fullName)
+                return enumDef;
+        }
+        return null;
+    }
+    /** 원시 스키마 타입이면 true (typedef 포함, AST 기준). C# 출력에 원시 타입명(i32 등)이 나오면 안 됨. */
+    isPrimitiveSchemaType(typeStr, ast, currentNamespace) {
+        return ast ? this.resolveTypeToASTDefinition(typeStr, currentNamespace, ast)?.kind === 'primitive' : false;
+    }
+    /** 값 이름으로 AST에 정의된 enum 풀네임 반환. 동일 값 이름이 여러 enum에 있으면 currentNamespace와 같은 네임스페이스 enum 우선. */
+    findEnumFullNameByValueName(ast, valueName, currentNamespace) {
+        if (!ast?.enums || !valueName)
+            return null;
+        let fallback = null;
+        for (const e of ast.enums) {
+            if (!Object.prototype.hasOwnProperty.call(e.values, valueName))
+                continue;
+            const full = this.getEnumFullName(e, ast);
+            if (currentNamespace && full.startsWith(currentNamespace + '.'))
+                return full;
+            if (!fallback)
+                fallback = full;
+        }
+        return fallback;
+    }
+    /** C# 타입 이름이 AST에 정의된 struct인지. AST 조회만 사용. */
+    isStructCSharpType(csharpTypeName, ast) {
+        return this.resolveTypeToASTDefinition(csharpTypeName, undefined, ast)?.kind === 'record';
+    }
+    /** AST 조회로만 판별. currentNamespace 있으면 short name 해석. */
+    isStructTypeFullName(typeStr, ast, currentNamespace) {
+        return this.resolveTypeToASTDefinition(typeStr, currentNamespace, ast)?.kind === 'record';
+    }
+    /** 필드 타입이 AST에 정의된 struct인지. list/set/map 요소가 아닌 필드 타입 자체가 struct일 때 true. currentNamespace 있으면 short name 해석. */
+    isStructType(type, ast, currentNamespace) {
+        return this.resolveTypeToASTDefinition(type, currentNamespace, ast)?.kind === 'record';
+    }
+    /** CreateDefault() 내 필드 초기화 RHS: IDL 기본값이 있으면 사용(호환), 없으면 struct→CreateDefault(), list/set/map→빈 컬렉션, primitive/enum→타입 기본값 */
+    generateCreateDefaultRhs(field, ast, _currentNamespace, parentStruct) {
+        if (parentStruct && ast && _currentNamespace) {
+            const msgDefault = this.buildMessageFirstFieldDefault(parentStruct, field, ast, _currentNamespace);
+            if (msgDefault != null)
+                return msgDefault;
+        }
+        // 필드에 명시된 기본값이 있으면 CreateDefault()에서도 동일하게 사용
+        if (field.defaultValue !== undefined && ast) {
+            const objInit = this.getCSharpStructObjectInitializer(field.defaultValue, field.type, _currentNamespace, ast);
+            if (objInit !== null)
+                return objInit;
+            const explicitDefault = this.getCSharpDefaultValue(field.defaultValue, field.type, ast, _currentNamespace);
+            if (explicitDefault !== 'null')
+                return explicitDefault;
+        }
+        const opt = !field.required;
+        if (typeof field.type === 'string') {
+            switch (field.type) {
+                case 'bool': return 'false';
+                case 'byte':
+                case 'int8':
+                case 'int16':
+                case 'int32':
+                case 'int64':
+                case 'float':
+                case 'double': return field.type === 'int64' ? '0L' : '0';
+                case 'string': return '""';
+                case 'binary': return opt ? 'null' : 'new byte[0]';
+                case 'datetime':
+                case 'timestamp':
+                case 'date': return 'default(DateTime)';
+                case 'time': return 'default(TimeSpan)';
+                case 'decimal':
+                case 'numeric': return '0m';
+                default: {
+                    const resolved = ast ? this.getCSharpType(field.type, ast, _currentNamespace) : '';
+                    if (resolved === 'string')
+                        return '""';
+                    if (resolved === 'bool')
+                        return 'false';
+                    if (resolved === 'int' || resolved === 'short' || resolved === 'byte')
+                        return '0';
+                    if (resolved === 'long')
+                        return '0L';
+                    if (resolved === 'double')
+                        return '0';
+                    if (resolved === 'DateTime')
+                        return 'default(DateTime)';
+                    if (resolved === 'TimeSpan')
+                        return 'default(TimeSpan)';
+                    if (resolved === 'decimal')
+                        return '0m';
+                    if (ast && this.isStructType(field.type, ast, _currentNamespace)) {
+                        const typeForDefault = this.getCSharpType(field.type, ast, _currentNamespace);
+                        return `${typeForDefault}.CreateDefault()`;
+                    }
+                    if (ast && this.isEnumType(field.type, ast, _currentNamespace)) {
+                        const typeForCast = this.getCSharpType(field.type, ast, _currentNamespace);
+                        return `(${typeForCast})0`;
+                    }
+                    return 'null';
+                }
+            }
+        }
+        if (typeof field.type === 'object' && field.type !== null && 'type' in field.type) {
+            switch (field.type.type) {
+                case 'list': {
+                    const elem = this.getCSharpType(field.type.elementType, ast, _currentNamespace);
+                    return `new List<${elem}>()`;
+                }
+                case 'set': {
+                    const elem = this.getCSharpType(field.type.elementType, ast, _currentNamespace);
+                    return `new HashSet<${elem}>()`;
+                }
+                case 'map': {
+                    const k = this.getCSharpType(field.type.keyType, ast, _currentNamespace);
+                    const v = this.getCSharpType(field.type.valueType, ast, _currentNamespace);
+                    return `new Dictionary<${k}, ${v}>()`;
+                }
+                case 'tablelink':
+                    return '0L';
+                default: return 'null';
+            }
+        }
+        return 'null';
+    }
+    generateCloneField(field, fieldName, ast, currentNamespace) {
+        const opt = !field.required;
+        const wrapOpt = (stmt) => opt ? `clone.${fieldName} = this.${fieldName} != null ? (${stmt}) : null;` : `clone.${fieldName} = ${stmt};`;
+        if (typeof field.type === 'string') {
+            switch (field.type) {
+                case 'bool':
+                case 'byte':
+                case 'int8':
+                case 'int16':
+                case 'int32':
+                case 'int64':
+                case 'float':
+                case 'double':
+                case 'datetime':
+                case 'timestamp':
+                case 'date':
+                case 'time':
+                case 'decimal':
+                case 'numeric':
+                    return `clone.${fieldName} = this.${fieldName};`;
+                case 'string':
+                    return `clone.${fieldName} = this.${fieldName};`;
+                case 'binary':
+                    return wrapOpt(`this.${fieldName}.Clone()`);
+                default:
+                    if (ast && (this.isEnumType(field.type, ast, currentNamespace) || this.isPrimitiveType(field.type, ast, currentNamespace) || !this.isStructType(field.type, ast, currentNamespace))) {
+                        return `clone.${fieldName} = this.${fieldName};`;
+                    }
+                    return wrapOpt(`this.${fieldName}.Clone()`);
+            }
+        }
+        if (typeof field.type === 'object' && 'type' in field.type) {
+            switch (field.type.type) {
+                case 'list':
+                    return wrapOpt(`this.${fieldName}.Select(item => ${this.generateCloneElement(field.type.elementType, ast, 'item', currentNamespace)}).ToList()`);
+                case 'set':
+                    return wrapOpt(`this.${fieldName}.Select(item => ${this.generateCloneElement(field.type.elementType, ast, 'item', currentNamespace)}).ToHashSet()`);
+                case 'map': {
+                    const keyClone = this.generateCloneElement(field.type.keyType, ast, 'kvp.Key', currentNamespace);
+                    const valueClone = this.generateCloneElement(field.type.valueType, ast, 'kvp.Value', currentNamespace);
+                    return wrapOpt(`this.${fieldName}.ToDictionary(kvp => ${keyClone}, kvp => ${valueClone})`);
+                }
+                case 'tablelink':
+                    return `clone.${fieldName} = this.${fieldName};`;
+                default:
+                    return wrapOpt(`this.${fieldName}.Clone()`);
+            }
+        }
+        return wrapOpt(`this.${fieldName}.Clone()`);
+    }
+    generateCloneElement(elementType, ast, varName = 'item', currentNamespace) {
+        // 1. 객체 타입인 경우
+        if (typeof elementType === 'object' && elementType !== null) {
+            if ('type' in elementType) {
+                switch (elementType.type) {
+                    case 'tablelink':
+                        return varName;
+                    case 'list':
+                        return `${varName}.Select(item => ${this.generateCloneElement(elementType.elementType, ast, 'item', currentNamespace)}).ToList()`;
+                    case 'set':
+                        return `${varName}.Select(item => ${this.generateCloneElement(elementType.elementType, ast, 'item', currentNamespace)}).ToHashSet()`;
+                    case 'map': {
+                        const keyClone = this.generateCloneElement(elementType.keyType, ast, 'kvp.Key', currentNamespace);
+                        const valueClone = this.generateCloneElement(elementType.valueType, ast, 'kvp.Value', currentNamespace);
+                        return `${varName}.ToDictionary(kvp => ${keyClone}, kvp => ${valueClone})`;
+                    }
+                    default:
+                        return `${varName}.Clone()`;
+                }
+            }
+            return `${varName}.Clone()`;
+        }
+        // 2. 문자열 타입인 경우
+        if (typeof elementType === 'string') {
+            // 기본 primitive 타입 처리
+            const primitiveTypes = ['bool', 'byte', 'int8', 'int16', 'int32', 'int64', 'float', 'double', 'string'];
+            if (primitiveTypes.includes(elementType)) {
+                return varName; // primitive는 그대로 사용
+            }
+            // AST를 사용하여 typedef/enum 확인
+            if (ast) {
+                // enum 타입은 Clone() 불필요
+                if (this.isEnumType(elementType, ast, currentNamespace)) {
+                    return varName;
+                }
+                // typedef로 정의된 primitive 타입인지 확인
+                if (this.isPrimitiveType(elementType, ast, currentNamespace)) {
+                    return varName;
+                }
+                // getCSharpType으로 실제 타입 확인
+                const resolvedType = this.getCSharpType(elementType, ast);
+                const csharpPrimitiveTypes = ['bool', 'byte', 'short', 'int', 'long', 'double', 'string'];
+                if (csharpPrimitiveTypes.includes(resolvedType)) {
+                    return varName;
+                }
+            }
+            if (elementType === 'binary') {
+                return `${varName}.Clone()`;
+            }
+            return `${varName}.Clone()`;
+        }
+        return `${varName}.Clone()`;
+    }
+    generateToStringField(field, fieldName, ast, currentNamespace) {
+        const csharpType = this.getCSharpType(field.type, ast, currentNamespace);
+        const isStruct = ast && (this.isStructType(field.type, ast, currentNamespace) || this.isStructCSharpType(csharpType, ast));
+        if (typeof field.type === 'string') {
+            const primitiveTypes = ['bool', 'byte', 'int8', 'int16', 'int32', 'int64', 'float', 'double'];
+            const dbTypes = ['datetime', 'timestamp', 'date', 'time', 'decimal', 'numeric'];
+            if (primitiveTypes.includes(field.type) || field.type === 'string') {
+                return `sb.Append(ci).Append("${field.name}: ").Append(this.${fieldName}).AppendLine(",");`;
+            }
+            if (dbTypes.includes(field.type)) {
+                return `sb.Append(ci).Append("${field.name}: ").Append(this.${fieldName}.ToString()).AppendLine(",");`;
+            }
+            if (field.type === 'binary') {
+                return `sb.Append(ci).Append("${field.name}: [").Append(this.${fieldName}?.Length ?? 0).AppendLine(" bytes],");`;
+            }
+            if (ast) {
+                const resolvedType = this.getCSharpType(field.type, ast, currentNamespace);
+                const csharpValueTypes = ['bool', 'byte', 'short', 'int', 'long', 'double', 'float', 'Single'];
+                if (csharpValueTypes.includes(resolvedType) || this.isEnumType(field.type, ast, currentNamespace)) {
+                    return `sb.Append(ci).Append("${field.name}: ").Append(this.${fieldName}.ToString()).AppendLine(",");`;
+                }
+            }
+            if (isStruct) {
+                return `sb.Append(ci).Append("${field.name}: ").Append(this.${fieldName}?.ToString(ci) ?? "null").AppendLine(",");`;
+            }
+            return `sb.Append(ci).Append("${field.name}: ").Append(this.${fieldName}?.ToString() ?? "null").AppendLine(",");`;
+        }
+        if (typeof field.type === 'object' && 'type' in field.type) {
+            switch (field.type.type) {
+                case 'tablelink':
+                    return `sb.Append(ci).Append("${field.name}: ").Append(this.${fieldName}.ToString()).AppendLine(",");`;
+                case 'list':
+                    return `sb.Append(ci).Append("${field.name}: [").Append(this.${fieldName}?.Count ?? 0).AppendLine(" items],");`;
+                case 'set':
+                    return `sb.Append(ci).Append("${field.name}: {").Append(this.${fieldName}?.Count ?? 0).AppendLine(" items},");`;
+                case 'map':
+                    return `sb.Append(ci).Append("${field.name}: {").Append(this.${fieldName}?.Count ?? 0).AppendLine(" pairs},");`;
+                default:
+                    if (isStruct) {
+                        return `sb.Append(ci).Append("${field.name}: ").Append(this.${fieldName}?.ToString(ci) ?? "null").AppendLine(",");`;
+                    }
+                    return `sb.Append(ci).Append("${field.name}: ").Append(this.${fieldName}?.ToString() ?? "null").AppendLine(",");`;
+            }
+        }
+        if (isStruct) {
+            return `sb.Append(ci).Append("${field.name}: ").Append(this.${fieldName}?.ToString(ci) ?? "null").AppendLine(",");`;
+        }
+        if (ast && (this.isPrimitiveType(field.type, ast, currentNamespace) || this.isEnumType(field.type, ast, currentNamespace))) {
+            return `sb.Append(ci).Append("${field.name}: ").Append(this.${fieldName}.ToString()).AppendLine(",");`;
+        }
+        return `sb.Append(ci).Append("${field.name}: ").Append(this.${fieldName}?.ToString() ?? "null").AppendLine(",");`;
+    }
+    resolveConstant(value, ast) {
+        // value 형식: "namespace.constant_name" 또는 "constant_name"
+        const parts = value.split('.');
+        if (parts.length === 0)
+            return null;
+        // constant_name만 있는 경우 또는 namespace.constant_name인 경우
+        const constantName = parts[parts.length - 1];
+        const namespace = parts.length > 1 ? parts.slice(0, -1).join('.') : '';
+        // AST에서 상수 찾기
+        for (const constant of ast.constants) {
+            const constName = constant.name.split('.').pop() || constant.name;
+            const constFullName = constant.name;
+            const constNamespace = constant.name.includes('.')
+                ? constant.name.substring(0, constant.name.lastIndexOf('.'))
+                : '';
+            // 이름이 일치하는지 확인 (전체 이름 또는 짧은 이름)
+            const nameMatches = constName === constantName || constFullName === value;
+            if (nameMatches) {
+                // namespace가 지정되었으면 namespace도 일치해야 함
+                if (namespace && constNamespace && constNamespace !== namespace) {
+                    continue;
+                }
+                // 상수 값이 숫자인 경우 반환
+                if (typeof constant.value === 'number') {
+                    return constant.value;
+                }
+                // 상수 값이 문자열인데 숫자로 파싱 가능한 경우
+                if (typeof constant.value === 'string') {
+                    const parsed = parseFloat(constant.value);
+                    if (!isNaN(parsed)) {
+                        return parsed;
+                    }
+                }
+            }
+        }
+        // 찾지 못한 경우 로그 출력 (디버깅용)
+        console.warn(`[DeukPack] Could not resolve constant: ${value}`);
+        return null;
+    }
+    generateTypedef(typedef) {
+        const lines = [];
+        // IDL typedef → C# using alias (C# doesn't support typedef)
+        // Map primitive/schema types to C# types
+        const csharpTypeMap = {
+            'long': 'System.Int64',
+            'int64': 'System.Int64',
+            'int32': 'System.Int32',
+            'int16': 'System.Int16',
+            'int8': 'System.SByte',
+            'string': 'System.String',
+            'int': 'System.Int32',
+            'bool': 'System.Boolean',
+            'byte': 'System.Byte',
+            'float': 'System.Single',
+            'double': 'System.Double',
+            'binary': 'byte[]'
+        };
+        let csharpType;
+        if (typeof typedef.type === 'string') {
+            csharpType = csharpTypeMap[typedef.type] || this.getCSharpType(typedef.type);
+        }
+        else {
+            csharpType = this.getCSharpType(typedef.type);
+        }
+        // Generate using alias at namespace start (C# requirement)
+        lines.push(`  using ${typedef.name} = ${csharpType};`);
+        return lines;
+    }
+    generateConstant(constant, ast) {
+        const lines = [];
+        const csharpType = this.getCSharpType(constant.type, ast);
+        const value = this.getCSharpDefaultValue(constant.value, constant.type, ast);
+        // C#에서 Dictionary, List, HashSet 같은 참조 타입은 const로 선언할 수 없으므로 readonly로 변경
+        const isReferenceType = typeof constant.type === 'object' && constant.type !== null &&
+            (constant.type.type === 'map' || constant.type.type === 'list' || constant.type.type === 'set') ||
+            (typeof csharpType === 'string' && (csharpType.startsWith('Dictionary') || csharpType.startsWith('List') || csharpType.startsWith('HashSet')));
+        if (isReferenceType) {
+            lines.push(`  public static readonly ${csharpType} ${constant.name} = ${value};`);
+        }
+        else {
+            lines.push(`  public const ${csharpType} ${constant.name} = ${value};`);
+        }
+        return lines;
+    }
+}
+exports.CSharpGenerator = CSharpGenerator;
+//# sourceMappingURL=CSharpGenerator.js.map