@supsis/supsis-js 1.1.3 → 1.1.4

package/dist/supsis.cjs.js

@@ -1,5 +1,5 @@
 /**
- * Supsis JS SDK v1.1.1
+ * Supsis JS SDK v1.1.3
  * Supsis API SDK - Browser ve Node.js için omnichannel messaging, chatbot, automation, task, ticket ve voice agent entegrasyonu
  * 
  * @license MIT
@@ -2308,7 +2308,16 @@ class Table extends BaseModule {
      * @returns {Promise<TableResponse[]>}
      */
     async list() {
-        return await this.http.get('/api/tables');
+        const response = await this.http.get('/api/tables');
+        // API returns {total, tables} format
+        if (response && response.tables) {
+            return response.tables;
+        }
+        // Fallback for array response
+        if (Array.isArray(response)) {
+            return response;
+        }
+        return [];
     }
 
     /**
@@ -2398,16 +2407,69 @@ class Table extends BaseModule {
 
     /**
      * Tablo alanı oluşturur
+     * 
      * @param {string} tableId - Tablo ID'si
-     * @param {Object} data - Alan verileri
-     * @param {string} data.name - Alan adı
-     * @param {string} data.type - Alan tipi: 'text', 'number', 'date', 'select', 'multiselect', 'checkbox', 'url', 'email', 'phone', 'user', 'contact', 'relation', 'formula', 'rollup', 'lookup', 'attachment', 'rating', 'currency', 'percent', 'duration', 'barcode'
-     * @param {Object} [data.options] - Alan seçenekleri
+     * @param {FieldCreateData} data - Alan verileri
      * @returns {Promise<FieldResponse>}
+     * 
+     * @example
+     * // Text alanı oluştur
+     * await supsis.table.createField(tableId, {
+     *   name: 'Ad Soyad',
+     *   apiName: 'fullName',
+     *   fieldType: 'text'
+     * });
+     * 
+     * @example
+     * // Dropdown alanı oluştur (static)
+     * await supsis.table.createField(tableId, {
+     *   name: 'Durum',
+     *   apiName: 'status',
+     *   fieldType: 'dropdown',
+     *   options: {
+     *     dropdown: {
+     *       mode: 'static',
+     *       multiple: false,
+     *       options: [
+     *         { value: 'active', color: 'rgb(222, 243, 233)' },
+     *         { value: 'inactive', color: 'rgb(250, 223, 217)' }
+     *       ]
+     *     }
+     *   }
+     * });
+     * 
+     * @example
+     * // Linked Record alanı oluştur
+     * await supsis.table.createField(tableId, {
+     *   name: 'Müşteri',
+     *   apiName: 'customer',
+     *   fieldType: 'linked-record',
+     *   options: {
+     *     linkedRecord: {
+     *       table: 'customersTableId',
+     *       labelField: 'nameFieldId'
+     *     }
+     *   }
+     * });
+     * 
+     * @example
+     * // AI alanı oluştur
+     * await supsis.table.createField(tableId, {
+     *   name: 'Özet',
+     *   apiName: 'summary',
+     *   fieldType: 'ai',
+     *   options: {
+     *     ai: {
+     *       prompt: 'Bu kaydı özetle',
+     *       runAt: 'on-every-change',
+     *       whichFieldsToProcess: 'all'
+     *     }
+     *   }
+     * });
      */
     async createField(tableId, data) {
         this._validateRequired({ tableId: tableId }, ['tableId']);
-        this._validateRequired(data, ['name', 'type']);
+        this._validateRequired(data, ['name', 'fieldType']);
         return await this.http.put('/api/tables/' + tableId + '/fields', data);
     }
 
@@ -2714,11 +2776,207 @@ class Table extends BaseModule {
  * @typedef {Object} FieldResponse
  * @property {string} _id - Alan ID
  * @property {string} name - Alan adı
- * @property {string} slug - URL-friendly isim
- * @property {string} type - Alan tipi
- * @property {Object} [options] - Alan seçenekleri
+ * @property {string} apiName - API ismi (slug)
+ * @property {FieldType} fieldType - Alan tipi
+ * @property {FieldValueType} [valueType] - Değer tipi
+ * @property {string} [icon] - Material icon adı (örn: 'text_fields', 'looks_one')
+ * @property {'left'|'center'|'right'} [alignment] - Hizalama
  * @property {number} [position] - Sıra
- * @property {boolean} [required] - Zorunlu mu
+ * @property {*} [defaultValue] - Varsayılan değer
+ * @property {boolean} [isIdentifierField] - Tanımlayıcı alan mı
+ * @property {FieldOptions} [options] - Alan seçenekleri (tip'e göre değişir)
+ * @property {Date} createdAt - Oluşturulma tarihi
+ * @property {Date} updatedAt - Güncellenme tarihi
+ */
+
+// ==================== FIELD TYPES ====================
+
+/**
+ * Desteklenen alan tipleri
+ * @typedef {'text'|'long-text'|'number'|'currency'|'datetime'|'dropdown'|'checkbox'|'url'|'email'|'phone'|'json'|'file'|'image'|'video'|'audio'|'color'|'automation-button'|'contact'|'ticket'|'task'|'event'|'form-submission'|'user'|'conversation'|'linked-record'|'ai'|'record_id'|'record_created_at'|'record_updated_at'|'record_created_by'|'record_updated_by'|'formula'|'lookup'|'auto-increment'} FieldType
+ */
+
+/**
+ * Değer tipleri
+ * @typedef {'string'|'number'|'date'|'boolean'|'array'|'json'|'asset'|'objectId'|'mixed'} FieldValueType
+ */
+
+/**
+ * Alan oluşturma verisi
+ * @typedef {Object} FieldCreateData
+ * @property {string} name - Alan adı (görünen isim)
+ * @property {string} [apiName] - API ismi (slug, otomatik oluşturulur)
+ * @property {FieldType} fieldType - Alan tipi
+ * @property {string} [icon] - Material icon adı
+ * @property {'left'|'center'|'right'} [alignment='left'] - Hizalama
+ * @property {*} [defaultValue] - Varsayılan değer
+ * @property {FieldOptions} [options] - Alan seçenekleri (tip'e göre)
+ */
+
+// ==================== FIELD OPTIONS BY TYPE ====================
+
+/**
+ * Alan seçenekleri (fieldType'a göre ilgili alt nesne kullanılır)
+ * @typedef {Object} FieldOptions
+ * @property {DatetimeFieldOptions} [datetime] - datetime alanı için seçenekler
+ * @property {NumberFieldOptions} [number] - number alanı için seçenekler
+ * @property {CurrencyFieldOptions} [currency] - currency alanı için seçenekler
+ * @property {DropdownFieldOptions} [dropdown] - dropdown alanı için seçenekler
+ * @property {LinkedRecordFieldOptions} [linkedRecord] - linked-record alanı için seçenekler
+ * @property {AIFieldOptions} [ai] - ai alanı için seçenekler
+ * @property {FormulaFieldOptions} [formula] - formula alanı için seçenekler
+ * @property {LookupFieldOptions} [lookup] - lookup alanı için seçenekler
+ * @property {AutoIncrementFieldOptions} [autoIncrement] - auto-increment alanı için seçenekler
+ * @property {ButtonFieldOptions} [button] - automation-button alanı için seçenekler
+ */
+
+/**
+ * Datetime alan seçenekleri
+ * @typedef {Object} DatetimeFieldOptions
+ * @property {string} [timezone='UTC'] - Zaman dilimi (örn: 'Europe/Istanbul', 'America/New_York')
+ * @property {string} [format='YYYY-MM-DD'] - Tarih formatı
+ *   - 'MM/DD/YYYY' - 12/31/2023
+ *   - 'DD/MM/YYYY' - 31/12/2023
+ *   - 'YYYY-MM-DD' - 2023-12-31
+ *   - 'MMM DD, YYYY' - Dec 31, 2023
+ *   - 'MMMM DD, YYYY' - December 31, 2023
+ * @property {boolean} [includeTime=true] - Saat dahil mi
+ * @property {string} [timeFormat='HH:mm'] - Saat formatı
+ *   - 'HH:mm' - 23:59
+ *   - 'hh:mm A' - 11:59 PM
+ *   - 'HH:mm:ss' - 23:59:59
+ * @property {boolean} [defaultNow=false] - Varsayılan olarak şu anki zaman mı
+ */
+
+/**
+ * Number alan seçenekleri
+ * @typedef {Object} NumberFieldOptions
+ * @property {string} [decimalFormat='0'] - Ondalık formatı
+ *   - '0' - Tam sayı
+ *   - '0.0' - 1 ondalık
+ *   - '0.00' - 2 ondalık
+ *   - '0.000' - 3 ondalık
+ */
+
+/**
+ * Currency alan seçenekleri
+ * @typedef {Object} CurrencyFieldOptions
+ * @property {string} [symbol='$'] - Para birimi sembolü
+ *   - '$' - USD
+ *   - '€' - EUR
+ *   - '£' - GBP
+ *   - '₺' - TRY
+ *   - '¥' - JPY/CNY
+ * @property {string} [decimalFormat='00'] - Ondalık formatı
+ */
+
+/**
+ * Dropdown alan seçenekleri
+ * @typedef {Object} DropdownFieldOptions
+ * @property {'static'|'dynamic'} [mode='static'] - Seçenek modu
+ *   - 'static': Sabit seçenekler (options dizisinden)
+ *   - 'dynamic': Başka tablodan dinamik seçenekler
+ * @property {boolean} [multiple=false] - Çoklu seçim
+ * @property {DropdownOption[]} [options] - Static mod için seçenekler
+ * @property {string} [remoteTable] - Dynamic mod için kaynak tablo ID
+ * @property {string} [remoteTableField] - Dynamic mod için kaynak alan ID
+ */
+
+/**
+ * Dropdown seçenek
+ * @typedef {Object} DropdownOption
+ * @property {string} value - Seçenek değeri
+ * @property {string} [color='rgb(210, 216, 243)'] - Arka plan rengi (RGB)
+ *   - 'rgb(232, 231, 228)' - Gray
+ *   - 'rgb(210, 216, 243)' - Blue
+ *   - 'rgb(222, 243, 233)' - Green
+ *   - 'rgb(255, 244, 188)' - Yellow
+ *   - 'rgb(250, 223, 217)' - Red
+ *   - 'rgb(250, 217, 239)' - Pink
+ *   - 'rgb(235, 217, 250)' - Purple
+ */
+
+/**
+ * Linked Record alan seçenekleri
+ * @typedef {Object} LinkedRecordFieldOptions
+ * @property {string} table - Referans edilecek tablo ID
+ * @property {string} [labelField] - Gösterilecek alan ID (varsayılan: ilk text alanı)
+ */
+
+/**
+ * AI alan seçenekleri
+ * @typedef {Object} AIFieldOptions
+ * @property {string} prompt - AI için prompt metni
+ * @property {'only-on-create'|'on-every-change'|'manual'} [runAt='only-on-create'] - Çalışma zamanı
+ *   - 'only-on-create': Sadece kayıt oluşturulduğunda
+ *   - 'on-every-change': Her değişiklikte
+ *   - 'manual': Manuel tetikleme (button ile)
+ * @property {'all'|'custom'} [whichFieldsToProcess='all'] - İşlenecek alanlar
+ * @property {string[]} [fieldsToProcess] - 'custom' seçiliyse işlenecek alan ID'leri
+ */
+
+/**
+ * Formula alan seçenekleri
+ * @typedef {Object} FormulaFieldOptions
+ * @property {string} expression - Formül ifadesi
+ *   Örnek: "{field1} + {field2}", "IF({status}='active', 'Yes', 'No')"
+ */
+
+/**
+ * Lookup alan seçenekleri
+ * @typedef {Object} LookupFieldOptions
+ * @property {string} linkedRecordField - Kaynak linked-record alan ID
+ * @property {string} targetField - Hedef tablodaki gösterilecek alan ID
+ */
+
+/**
+ * Auto Increment alan seçenekleri
+ * @typedef {Object} AutoIncrementFieldOptions
+ * @property {'number'|'string'} [format='number'] - Çıktı formatı
+ *   - 'number': Sadece sayı (1, 2, 3, ...)
+ *   - 'string': Prefix/suffix ile (INV-001, INV-002, ...)
+ * @property {string} [prefix] - Ön ek (string format için, örn: 'INV-')
+ * @property {string} [suffix] - Son ek (string format için, örn: '-2024')
+ * @property {number} [startValue=1] - Başlangıç değeri
+ * @property {number} [increment=1] - Artış miktarı
+ */
+
+/**
+ * Automation Button alan seçenekleri
+ * @typedef {Object} ButtonFieldOptions
+ * @property {string} [defaultLabel] - Button etiketi
+ * @property {boolean} [disableWhenClicked=false] - Tıklandığında devre dışı bırak
+ * @property {string} [automation] - Tetiklenecek otomasyon ID
+ */
+
+// ==================== META FIELD TYPES ====================
+
+/**
+ * Meta alan tipleri (sistem tarafından otomatik yönetilir, readonly)
+ * 
+ * - record_id: Kayıt benzersiz ID'si (string)
+ * - record_created_at: Oluşturulma tarihi (date)
+ * - record_updated_at: Son güncelleme tarihi (date)  
+ * - record_created_by: Oluşturan kullanıcı (objectId -> User)
+ * - record_updated_by: Güncelleyen kullanıcı (objectId -> User)
+ * 
+ * @typedef {'record_id'|'record_created_at'|'record_updated_at'|'record_created_by'|'record_updated_by'} MetaFieldType
+ */
+
+// ==================== MODULE FIELD TYPES ====================
+
+/**
+ * Modül alan tipleri (Supsis modüllerine referans)
+ * 
+ * - contact: Kişi modülüne referans
+ * - ticket: Destek talebi modülüne referans
+ * - task: Görev modülüne referans
+ * - event: Etkinlik modülüne referans
+ * - user: Kullanıcı modülüne referans
+ * - conversation: Sohbet/Görüşme modülüne referans
+ * - form-submission: Form gönderimi modülüne referans
+ * 
+ * @typedef {'contact'|'ticket'|'task'|'event'|'user'|'conversation'|'form-submission'} ModuleFieldType
  */
 
 /**
@@ -2779,31 +3037,113 @@ class Module extends BaseModule {
      * @returns {Promise<ModuleDefinitionResponse[]>}
      */
     async list() {
-        return await this.http.get('/api/module');
+        const response = await this.http.get('/api/module');
+        // API may return {total, modules} or direct array
+        if (response && response.modules) {
+            return response.modules;
+        }
+        // Fallback for array response
+        if (Array.isArray(response)) {
+            return response;
+        }
+        return [];
     }
 
     /**
      * Modül oluşturur
-     * @param {Object} data - Modül verileri
-     * @param {string} data.name - Modül adı (API name)
-     * @param {string} data.displayName - Görünen ad
-     * @param {Object[]} [data.fields] - Alan tanımları
+     * 
+     * İki tip modül oluşturulabilir:
+     * 1. 'module': Bir tabloya bağlı modül (CRM modülü gibi)
+     * 2. 'relation': İki tablo/modül arasında ilişki tanımı
+     * 
+     * @param {ModuleCreateData} data - Modül verileri
      * @returns {Promise<ModuleDefinitionResponse>}
+     * 
+     * @example
+     * // Tabloya bağlı modül oluştur
+     * await supsis.module.create({
+     *   displayName: 'Leads',
+     *   description: 'Potansiyel müşteriler',
+     *   type: 'module',
+     *   icon: 'person_add',
+     *   module: {
+     *     table: 'tableId123',
+     *     settings: {
+     *       showInMainMenu: true,
+     *       apiEnabled: true
+     *     }
+     *   }
+     * });
+     * 
+     * @example
+     * // Table-to-Table relation oluştur
+     * await supsis.module.create({
+     *   displayName: 'Müşteri Siparişleri',
+     *   type: 'relation',
+     *   icon: 'link',
+     *   relation: {
+     *     type: 'table-to-table',
+     *     tableToTable: {
+     *       from: { table: 'customersTableId', connectionType: '_id' },
+     *       to: { table: 'ordersTableId', connectionType: 'field', field: 'customerField' }
+     *     }
+     *   }
+     * });
+     * 
+     * @example
+     * // Standart modül -> Table relation oluştur
+     * await supsis.module.create({
+     *   displayName: 'Kişi Satın Alımları',
+     *   type: 'relation',
+     *   icon: 'shopping_cart',
+     *   relation: {
+     *     type: 'standart-to-table',
+     *     standartToTable: {
+     *       from: { module: 'contact', connectionType: 'field', field: '_id' },
+     *       to: { table: 'purchasesTableId', connectionType: 'field', field: 'contactField' }
+     *     }
+     *   }
+     * });
      */
     async create(data) {
-        this._validateRequired(data, ['name', 'displayName']);
+        this._validateRequired(data, ['displayName', 'type']);
+        
+        if (data.type === 'module') {
+            this._validateRequired(data, ['module']);
+            this._validateRequired(data.module, ['table']);
+        } else if (data.type === 'relation') {
+            this._validateRequired(data, ['relation']);
+            this._validateRequired(data.relation, ['type']);
+        }
+        
         return await this.http.post('/api/module', data);
     }
 
     /**
      * Modülü günceller
-     * @param {string} moduleName - Modül adı
-     * @param {Object} data - Güncellenecek veriler
+     * @param {string} moduleName - Modül adı (API name)
+     * @param {Object} updatingFields - Güncellenecek alanlar
+     * @param {string} [updatingFields.displayName] - Görünen ad
+     * @param {string} [updatingFields.description] - Açıklama
+     * @param {string} [updatingFields.icon] - Material icon adı
+     * @param {number} [updatingFields.position] - Sıralama pozisyonu
+     * @param {ModuleSettings} [updatingFields.settings] - Modül ayarları (type='module' için)
      * @returns {Promise<ModuleDefinitionResponse>}
      */
-    async update(moduleName, data) {
+    async update(moduleName, updatingFields) {
+        this._validateRequired({ moduleName: moduleName }, ['moduleName']);
+        return await this.http.post('/api/module/' + moduleName, { updatingFields: updatingFields });
+    }
+    
+    /**
+     * Modül adına göre modül getirir
+     * @param {string} moduleName - Modül adı (API name)
+     * @returns {Promise<ModuleDefinitionResponse|null>}
+     */
+    async getByName(moduleName) {
         this._validateRequired({ moduleName: moduleName }, ['moduleName']);
-        return await this.http.post('/api/module/' + moduleName, data);
+        const modules = await this.list();
+        return modules.find(function(m) { return m.moduleName === moduleName; }) || null;
     }
 
     /**
@@ -2967,14 +3307,113 @@ class Module extends BaseModule {
  * @typedef {Object} ModuleDefinitionResponse
  * @property {string} _id - Modül ID
  * @property {string} siteId - Site ID
- * @property {string} name - Modül adı (API name)
+ * @property {string} moduleName - Modül adı (otomatik oluşturulur)
+ * @property {string} apiName - API adı
  * @property {string} displayName - Görünen ad
  * @property {string} [description] - Açıklama
- * @property {string} [icon] - İkon
- * @property {ModuleFieldDefinition[]} fields - Alan tanımları
+ * @property {string} [icon] - Material icon adı
+ * @property {'module'|'relation'} type - Modül tipi
+ * @property {ModuleConfig} [module] - type='module' için konfigürasyon
+ * @property {RelationConfig} [relation] - type='relation' için konfigürasyon
+ * @property {number} [position] - Sıralama pozisyonu
  * @property {Date} createdAt - Oluşturulma tarihi
+ * @property {Date} updatedAt - Güncellenme tarihi
+ */
+
+// ==================== MODULE CREATE DATA ====================
+
+/**
+ * Modül oluşturma verisi
+ * @typedef {Object} ModuleCreateData
+ * @property {string} displayName - Görünen ad (zorunlu)
+ * @property {string} [description] - Açıklama
+ * @property {'module'|'relation'} type - Modül tipi (zorunlu)
+ * @property {string} [icon] - Material icon adı (örn: 'widgets', 'list', 'person_add')
+ * @property {ModuleConfig} [module] - type='module' için konfigürasyon
+ * @property {RelationConfig} [relation] - type='relation' için konfigürasyon
+ */
+
+/**
+ * Module tipi konfigürasyonu (type='module' için)
+ * @typedef {Object} ModuleConfig
+ * @property {string} table - Bağlı tablo ID'si (zorunlu)
+ * @property {ModuleSettings} [settings] - Modül ayarları
+ */
+
+/**
+ * Modül ayarları
+ * @typedef {Object} ModuleSettings
+ * @property {boolean} [showInMainMenu=true] - Ana menüde göster
+ * @property {boolean} [apiEnabled=true] - API erişimi aktif
+ */
+
+// ==================== RELATION CONFIG ====================
+
+/**
+ * Relation tipi konfigürasyonu (type='relation' için)
+ * @typedef {Object} RelationConfig
+ * @property {'table-to-table'|'table-to-standart'|'standart-to-table'} type - İlişki tipi
+ * @property {TableToTableRelation} [tableToTable] - Tablo-Tablo ilişkisi
+ * @property {StandartToTableRelation} [standartToTable] - StandartModül-Tablo ilişkisi
+ * @property {TableToStandartRelation} [tableToStandart] - Tablo-StandartModül ilişkisi
+ */
+
+/**
+ * Tablo-Tablo ilişki tanımı
+ * 
+ * Örnek: Yazarlar ve Kitaplar tabloları
+ * - Yazarlar tablosunda Kitaplar listesini göstermek için:
+ *   from: { table: 'yazarlarId', connectionType: '_id' }
+ *   to: { table: 'kitaplarId', connectionType: 'field', field: 'yazarFieldId' }
+ * 
+ * @typedef {Object} TableToTableRelation
+ * @property {TableConnectionPoint} from - Kaynak tablo bağlantı noktası
+ * @property {TableConnectionPoint} to - Hedef tablo bağlantı noktası
+ */
+
+/**
+ * Tablo bağlantı noktası
+ * @typedef {Object} TableConnectionPoint
+ * @property {string} table - Tablo ID
+ * @property {'_id'|'field'} connectionType - Bağlantı tipi
+ *   - '_id': Tablonun _id alanı ile bağlan
+ *   - 'field': Belirli bir alan ile bağlan
+ * @property {string} [field] - connectionType='field' ise alan ID
+ */
+
+/**
+ * Standart Modül-Tablo ilişki tanımı
+ * 
+ * Örnek: Contact modülünde SatınAlımlar tablosunu göstermek için:
+ *   from: { module: 'contact', connectionType: 'field', field: '_id' }
+ *   to: { table: 'satinAlimlarId', connectionType: 'field', field: 'contactFieldId' }
+ * 
+ * @typedef {Object} StandartToTableRelation
+ * @property {StandartModuleConnectionPoint} from - Kaynak standart modül bağlantı noktası
+ * @property {TableConnectionPoint} to - Hedef tablo bağlantı noktası
+ */
+
+/**
+ * Standart modül bağlantı noktası
+ * @typedef {Object} StandartModuleConnectionPoint
+ * @property {'contact'|'ticket'|'task'|'calendar'|'email'} module - Standart modül adı
+ * @property {'field'|'customProperties'} connectionType - Bağlantı tipi
+ *   - 'field': Standart alan ile bağlan (_id, name, email, phone, whatsappNumber)
+ *   - 'customProperties': Özel alan ile bağlan
+ * @property {string} field - Bağlantı alanı
+ *   - contact: _id, name, email, phone, whatsappNumber
+ *   - ticket/task/calendar/email: _id
+ */
+
+/**
+ * Tablo-Standart Modül ilişki tanımı
+ * @typedef {Object} TableToStandartRelation
+ * @property {TableConnectionPoint} from - Kaynak tablo bağlantı noktası
+ * @property {StandartModuleConnectionPoint} to - Hedef standart modül bağlantı noktası
  */
 
+// ==================== RECORD TYPES ====================
+
 /**
  * @typedef {Object} ModuleFieldDefinition
  * @property {string} name - Alan adı
@@ -4188,6 +4627,1201 @@ class SupsisModuleAPI {
  * @property {number} [retryCount=3] - Başarısız isteklerde retry sayısı
  */
 
+/**
+ * SupsisAppBuilder
+ * Template-driven application builder for Supsis platform.
+ * Creates tables, fields, modules, cache entries and seed data from a template.
+ * 
+ * @module SupsisAppBuilder
+ * @example
+ * const { SupsisJS, SupsisAppBuilder } = require('@supsis/supsis-js');
+ * 
+ * const supsis = new SupsisJS({ email, password, siteId });
+ * await supsis.connect();
+ * 
+ * const appBuilder = new SupsisAppBuilder(supsis);
+ * await appBuilder.build(template);
+ */
+
+/**
+ * App Builder Validation Error
+ */
+class AppBuilderValidationError extends Error {
+    constructor(message, details) {
+        super(message);
+        this.name = 'AppBuilderValidationError';
+        this.details = details || {};
+    }
+}
+
+/**
+ * App Builder Build Error
+ */
+class AppBuilderBuildError extends Error {
+    constructor(message, phase, details) {
+        super(message);
+        this.name = 'AppBuilderBuildError';
+        this.phase = phase;
+        this.details = details || {};
+    }
+}
+
+/**
+ * Meta field definitions (auto-added to every table)
+ */
+const META_FIELDS = [
+    { name: 'Record ID', apiName: 'record_id', fieldType: 'record_id', icon: 'tag' },
+    { name: 'Created At', apiName: 'record_created_at', fieldType: 'record_created_at', icon: 'add_circle_outline' },
+    { name: 'Updated At', apiName: 'record_updated_at', fieldType: 'record_updated_at', icon: 'update' },
+    { name: 'Created By', apiName: 'record_created_by', fieldType: 'record_created_by', icon: 'person_add' },
+    { name: 'Updated By', apiName: 'record_updated_by', fieldType: 'record_updated_by', icon: 'person_outline' }
+];
+
+/**
+ * SupsisAppBuilder - Template-driven application builder
+ */
+class SupsisAppBuilder {
+    /**
+     * @param {import('../SupsisJS.js').SupsisJS} supsisInstance - Connected SupsisJS instance
+     */
+    constructor(supsisInstance) {
+        if (!supsisInstance) {
+            throw new AppBuilderValidationError('SupsisJS instance is required');
+        }
+        
+        this._supsis = supsisInstance;
+        this._verbose = false;
+        
+        // Build state
+        this._uidMap = {};           // uid -> { type, id, data }
+        this._tableMap = {};         // uid -> table response
+        this._fieldMap = {};         // tableUid.fieldApiName -> field response
+        this._moduleMap = {};        // uid -> module response
+        this._seedMap = {};          // uid -> record response
+        this._pendingFields = [];    // Fields waiting for linked table to be created
+    }
+
+    /**
+     * Internal logging
+     * @private
+     */
+    _log(type, ...args) {
+        if (!this._verbose) return;
+        
+        const prefix = '[AppBuilder]';
+        const timestamp = new Date().toISOString();
+        
+        switch (type) {
+            case 'info':
+                console.log(`${prefix} ${timestamp} INFO:`, ...args);
+                break;
+            case 'warn':
+                console.warn(`${prefix} ${timestamp} WARN:`, ...args);
+                break;
+            case 'error':
+                console.error(`${prefix} ${timestamp} ERROR:`, ...args);
+                break;
+            case 'success':
+                console.log(`${prefix} ${timestamp} ✓`, ...args);
+                break;
+            case 'phase':
+                console.log(`${prefix} ${timestamp} ═══════════════════════════════════`);
+                console.log(`${prefix} ${timestamp} PHASE:`, ...args);
+                console.log(`${prefix} ${timestamp} ═══════════════════════════════════`);
+                break;
+            default:
+                console.log(`${prefix} ${timestamp}`, ...args);
+        }
+    }
+
+    /**
+     * Generate description with app builder metadata
+     * @private
+     */
+    _generateDescription(appName, uid, customDescription) {
+        const meta = `creator=supsis-app-builder;appname=${appName};uid=${uid}`;
+        return customDescription ? `${customDescription}\n${meta}` : meta;
+    }
+
+    /**
+     * Parse description to extract app builder metadata
+     * @private
+     */
+    _parseDescription(description) {
+        if (!description) return null;
+        
+        const match = description.match(/creator=supsis-app-builder;appname=([^;]+);uid=([^\s\n]+)/);
+        if (match) {
+            return {
+                creator: 'supsis-app-builder',
+                appName: match[1],
+                uid: match[2]
+            };
+        }
+        return null;
+    }
+
+    /**
+     * Validate template structure
+     * @private
+     */
+    _validateTemplate(template) {
+        const errors = [];
+        
+        // Required fields
+        if (!template.name) errors.push('Template name is required');
+        if (!template.version) errors.push('Template version is required');
+        
+        // Validate tables
+        if (template.tables) {
+            const tableUids = new Set();
+            
+            template.tables.forEach((table, idx) => {
+                if (!table.name) errors.push(`Table[${idx}]: name is required`);
+                if (!table.uid) errors.push(`Table[${idx}]: uid is required`);
+                
+                if (table.uid) {
+                    if (tableUids.has(table.uid)) {
+                        errors.push(`Table[${idx}]: duplicate uid '${table.uid}'`);
+                    }
+                    tableUids.add(table.uid);
+                }
+                
+                // Validate fields
+                if (table.fields) {
+                    const fieldApiNames = new Set();
+                    
+                    table.fields.forEach((field, fidx) => {
+                        if (!field.name) errors.push(`Table[${idx}].Field[${fidx}]: name is required`);
+                        if (!field.fieldType) errors.push(`Table[${idx}].Field[${fidx}]: fieldType is required`);
+                        
+                        if (field.apiName) {
+                            if (fieldApiNames.has(field.apiName)) {
+                                errors.push(`Table[${idx}].Field[${fidx}]: duplicate apiName '${field.apiName}'`);
+                            }
+                            fieldApiNames.add(field.apiName);
+                        }
+                    });
+                }
+            });
+        }
+        
+        // Validate modules
+        if (template.modules) {
+            template.modules.forEach((mod, idx) => {
+                if (!mod.name) errors.push(`Module[${idx}]: name is required`);
+                if (!mod.table) errors.push(`Module[${idx}]: table (uid) is required`);
+            });
+        }
+        
+        // Validate cache keys
+        if (template.cache) {
+            Object.keys(template.cache).forEach(key => {
+                if (!key.startsWith(template.name)) {
+                    errors.push(`Cache key '${key}' must start with app name '${template.name}'`);
+                }
+            });
+        }
+        
+        // Validate seed data
+        if (template.seed) {
+            template.seed.forEach((item, idx) => {
+                if (!item.module) errors.push(`Seed[${idx}]: module is required`);
+                if (!item.data) errors.push(`Seed[${idx}]: data is required`);
+            });
+        }
+        
+        if (errors.length > 0) {
+            throw new AppBuilderValidationError('Template validation failed', { errors });
+        }
+    }
+
+    /**
+     * Resolve UID to actual ID
+     * @private
+     */
+    _resolveUid(uid, type) {
+        if (!uid) return null;
+        
+        // Check if it's already a real ID (24 char hex string)
+        if (/^[a-f0-9]{24}$/i.test(uid)) {
+            return uid;
+        }
+        
+        // Look up in maps
+        if (type === 'table' && this._tableMap[uid]) {
+            return this._tableMap[uid]._id;
+        }
+        
+        if (type === 'field') {
+            // uid format: tableUid.fieldApiName
+            const parts = uid.split('.');
+            if (parts.length >= 2) {
+                const tableUid = parts.slice(0, -1).join('.');
+                const fieldApiName = parts[parts.length - 1];
+                const key = `${tableUid}.${fieldApiName}`;
+                if (this._fieldMap[key]) {
+                    return this._fieldMap[key]._id;
+                }
+            }
+        }
+        
+        if (type === 'module' && this._moduleMap[uid]) {
+            return this._moduleMap[uid]._id;
+        }
+        
+        if (type === 'seed' && this._seedMap[uid]) {
+            return this._seedMap[uid]._id;
+        }
+        
+        return null;
+    }
+
+    /**
+     * Find existing table by description metadata
+     * @private
+     */
+    async _findExistingTable(appName, uid) {
+        try {
+            const tables = await this._supsis.table.list();
+            
+            for (const table of tables) {
+                const meta = this._parseDescription(table.description);
+                if (meta && meta.appName === appName && meta.uid === uid) {
+                    return table;
+                }
+            }
+        } catch (e) {
+            this._log('warn', 'Failed to list tables:', e.message);
+        }
+        return null;
+    }
+
+    /**
+     * Find existing module by description metadata
+     * @private
+     */
+    async _findExistingModule(appName, uid) {
+        try {
+            const modules = await this._supsis.module.list();
+            
+            for (const mod of modules) {
+                const meta = this._parseDescription(mod.description);
+                if (meta && meta.appName === appName && meta.uid === uid) {
+                    return mod;
+                }
+            }
+        } catch (e) {
+            this._log('warn', 'Failed to list modules:', e.message);
+        }
+        return null;
+    }
+
+    /**
+     * Infer data type for cache value
+     * @private
+     */
+    _inferCacheDataType(value) {
+        if (value === null || value === undefined) return 'mixed';
+        if (typeof value === 'string') return 'string';
+        if (typeof value === 'number') return 'number';
+        if (typeof value === 'boolean') return 'boolean';
+        if (value instanceof Date) return 'date';
+        if (Array.isArray(value)) return 'array';
+        if (typeof value === 'object') return 'json';
+        return 'mixed';
+    }
+
+    /**
+     * Build tables (Phase 1 - create tables without linked-record fields)
+     * @private
+     */
+    async _buildTables(template, options) {
+        this._log('phase', 'Building Tables');
+        
+        const tables = template.tables || [];
+        
+        for (const tableDef of tables) {
+            const uid = tableDef.uid;
+            const appName = template.name;
+            
+            // Check if table already exists
+            let existingTable = await this._findExistingTable(appName, uid);
+            
+            if (existingTable) {
+                if (options.skipExisting) {
+                    this._log('info', `Table '${tableDef.name}' (${uid}) already exists, skipping...`);
+                    this._tableMap[uid] = existingTable;
+                    continue;
+                }
+                
+                if (options.updateExisting) {
+                    this._log('info', `Table '${tableDef.name}' (${uid}) exists, updating...`);
+                    existingTable = await this._supsis.table.update(existingTable._id, {
+                        name: tableDef.name,
+                        icon: tableDef.icon,
+                        description: this._generateDescription(appName, uid, tableDef.description),
+                        category: {
+                            name: appName,
+                            icon: tableDef.categoryIcon || 'apps'
+                        }
+                    });
+                    this._tableMap[uid] = existingTable;
+                    continue;
+                }
+            }
+            
+            // Create new table
+            if (options.dryRun) {
+                this._log('info', `[DRY-RUN] Would create table: ${tableDef.name} (${uid})`);
+                this._tableMap[uid] = { _id: `dry-run-${uid}`, name: tableDef.name, uid };
+            } else {
+                this._log('info', `Creating table: ${tableDef.name} (${uid})`);
+                
+                const tableData = {
+                    name: tableDef.name,
+                    description: this._generateDescription(appName, uid, tableDef.description),
+                    icon: tableDef.icon || 'table_chart',
+                    category: {
+                        name: appName,
+                        icon: tableDef.categoryIcon || 'apps'
+                    }
+                };
+                
+                const created = await this._supsis.table.create(tableData);
+                this._tableMap[uid] = created;
+                this._log('success', `Table created: ${tableDef.name} -> ${created._id}`);
+            }
+        }
+    }
+
+    /**
+     * Build fields (Phase 2 - create fields, queue linked-records for Phase 3)
+     * @private
+     */
+    async _buildFields(template, options) {
+        this._log('phase', 'Building Fields (Phase 1 - Non-linked fields)');
+        
+        const tables = template.tables || [];
+        
+        for (const tableDef of tables) {
+            const tableUid = tableDef.uid;
+            const table = this._tableMap[tableUid];
+            
+            if (!table) {
+                this._log('warn', `Table not found for uid: ${tableUid}`);
+                continue;
+            }
+            
+            const tableId = table._id;
+            const fields = tableDef.fields || [];
+            
+            // Get existing fields
+            let existingFields = [];
+            if (!options.dryRun) {
+                try {
+                    existingFields = await this._supsis.table.listFields(tableId);
+                } catch (e) {
+                    this._log('warn', `Failed to list fields for table ${tableId}:`, e.message);
+                }
+            }
+            
+            // First, add meta fields if not present
+            for (const metaField of META_FIELDS) {
+                const existing = existingFields.find(f => f.fieldType === metaField.fieldType);
+                if (!existing) {
+                    if (options.dryRun) {
+                        this._log('info', `[DRY-RUN] Would create meta field: ${metaField.name} in ${tableDef.name}`);
+                    } else {
+                        try {
+                            this._log('info', `Creating meta field: ${metaField.name} in ${tableDef.name}`);
+                            await this._supsis.table.createField(tableId, metaField);
+                        } catch (e) {
+                            this._log('warn', `Failed to create meta field ${metaField.name}:`, e.message);
+                        }
+                    }
+                }
+            }
+            
+            // Process user-defined fields
+            for (const fieldDef of fields) {
+                const fieldKey = `${tableUid}.${fieldDef.apiName || fieldDef.name}`;
+                
+                // Check if field needs linked table that doesn't exist yet
+                if (fieldDef.fieldType === 'linked-record') {
+                    const linkedTableUid = (fieldDef.options && fieldDef.options.linkedRecord) 
+                        ? fieldDef.options.linkedRecord.table 
+                        : null;
+                    
+                    // Check if it's already a real ID or needs to be resolved
+                    const isRealId = linkedTableUid && /^[a-f0-9]{24}$/i.test(linkedTableUid);
+                    const linkedTable = linkedTableUid && !isRealId ? this._tableMap[linkedTableUid] : null;
+                    
+                    // If not a real ID and table not yet created, queue for later
+                    if (!isRealId && !linkedTable && linkedTableUid) {
+                        // Queue for Phase 3
+                        this._pendingFields.push({
+                            tableUid: tableUid,
+                            tableId: tableId,
+                            tableName: tableDef.name,
+                            fieldDef: fieldDef,
+                            fieldKey: fieldKey
+                        });
+                        this._log('info', `Queued linked-record field '${fieldDef.name}' (waiting for ${linkedTableUid})`);
+                        continue;
+                    }
+                }
+                
+                await this._createOrUpdateField(tableId, tableDef.name, tableUid, fieldDef, existingFields, options);
+            }
+        }
+    }
+
+    /**
+     * Build pending linked-record fields (Phase 3)
+     * @private
+     */
+    async _buildPendingFields(template, options) {
+        if (this._pendingFields.length === 0) return;
+        
+        this._log('phase', 'Building Fields (Phase 2 - Linked-record fields)');
+        
+        for (const pending of this._pendingFields) {
+            const { tableId, tableName, tableUid, fieldDef, fieldKey } = pending;
+            
+            // Get existing fields
+            let existingFields = [];
+            if (!options.dryRun) {
+                try {
+                    existingFields = await this._supsis.table.listFields(tableId);
+                } catch (e) {
+                    // ignore
+                }
+            }
+            
+            await this._createOrUpdateField(tableId, tableName, tableUid, fieldDef, existingFields, options);
+        }
+        
+        this._pendingFields = [];
+    }
+
+    /**
+     * Create or update a single field
+     * @private
+     */
+    async _createOrUpdateField(tableId, tableName, tableUid, fieldDef, existingFields, options) {
+        const apiName = fieldDef.apiName || this._toApiName(fieldDef.name);
+        const fieldKey = `${tableUid}.${apiName}`;
+        
+        // Check if field exists
+        const existing = existingFields.find(f => 
+            f.apiName === apiName || f.name === fieldDef.name
+        );
+        
+        // Resolve linked-record table/field IDs
+        let resolvedOptions = fieldDef.options;
+        if (fieldDef.fieldType === 'linked-record' && fieldDef.options && fieldDef.options.linkedRecord) {
+            const linkedTableUid = fieldDef.options.linkedRecord.table;
+            const labelFieldName = fieldDef.options.linkedRecord.labelField;
+            
+            // Check if table is already a real ID (24 char hex string)
+            const isTableRealId = /^[a-f0-9]{24}$/i.test(linkedTableUid);
+            let resolvedTableId = linkedTableUid;
+            
+            if (!isTableRealId) {
+                // Try to resolve UID to real ID
+                const linkedTable = this._tableMap[linkedTableUid];
+                
+                if (!linkedTable) {
+                    this._log('error', `Cannot resolve linked table UID: ${linkedTableUid}`);
+                    this._log('error', `Available tables in map: ${Object.keys(this._tableMap).join(', ')}`);
+                    throw new AppBuilderBuildError(
+                        `Cannot create field '${fieldDef.name}': linked table '${linkedTableUid}' not found`,
+                        'fields',
+                        { field: fieldDef.name, linkedTableUid: linkedTableUid, availableTables: Object.keys(this._tableMap) }
+                    );
+                }
+                
+                resolvedTableId = linkedTable._id;
+                this._log('info', `Resolved linked table UID '${linkedTableUid}' -> ${resolvedTableId}`);
+            }
+            
+            // Resolve labelField to field ID
+            let resolvedLabelFieldId = labelFieldName;
+            if (labelFieldName && !/^[a-f0-9]{24}$/i.test(labelFieldName)) {
+                // labelField is apiName, need to resolve to field ID
+                try {
+                    const linkedTableFields = await this._supsis.table.listFields(resolvedTableId);
+                    const labelField = linkedTableFields.find(function(f) {
+                        return f.apiName === labelFieldName || f.slug === labelFieldName || f.name === labelFieldName;
+                    });
+                    
+                    if (labelField) {
+                        resolvedLabelFieldId = labelField._id;
+                        this._log('info', `Resolved labelField '${labelFieldName}' -> ${resolvedLabelFieldId}`);
+                    } else {
+                        this._log('warn', `LabelField '${labelFieldName}' not found in table ${resolvedTableId}, using apiName`);
+                    }
+                } catch (e) {
+                    this._log('warn', `Failed to resolve labelField '${labelFieldName}': ${e.message}`);
+                }
+            }
+            
+            resolvedOptions = Object.assign({}, fieldDef.options, {
+                linkedRecord: {
+                    table: resolvedTableId,
+                    labelField: resolvedLabelFieldId
+                }
+            });
+        }
+        
+        const fieldData = {
+            name: fieldDef.name,
+            apiName: apiName,
+            fieldType: fieldDef.fieldType,
+            icon: fieldDef.icon,
+            alignment: fieldDef.alignment || 'left',
+            defaultValue: fieldDef.defaultValue,
+            options: resolvedOptions
+        };
+        
+        if (existing) {
+            if (options.skipExisting) {
+                this._log('info', `Field '${fieldDef.name}' in ${tableName} already exists, skipping...`);
+                this._fieldMap[fieldKey] = existing;
+                return;
+            }
+            
+            if (options.updateExisting) {
+                if (options.dryRun) {
+                    this._log('info', `[DRY-RUN] Would update field: ${fieldDef.name} in ${tableName}`);
+                } else {
+                    this._log('info', `Updating field: ${fieldDef.name} in ${tableName}`);
+                    
+                    // Only update allowed fields (not fieldType)
+                    const updateData = {
+                        name: fieldDef.name,
+                        icon: fieldDef.icon,
+                        alignment: fieldDef.alignment,
+                        defaultValue: fieldDef.defaultValue,
+                        options: resolvedOptions
+                    };
+                    
+                    const updated = await this._supsis.table.updateField(tableId, existing._id, updateData);
+                    this._fieldMap[fieldKey] = updated;
+                    this._log('success', `Field updated: ${fieldDef.name}`);
+                }
+                return;
+            }
+        }
+        
+        // Create new field
+        if (options.dryRun) {
+            this._log('info', `[DRY-RUN] Would create field: ${fieldDef.name} in ${tableName}`);
+            this._fieldMap[fieldKey] = { _id: `dry-run-${fieldKey}`, ...fieldData };
+        } else {
+            this._log('info', `Creating field: ${fieldDef.name} (${fieldDef.fieldType}) in ${tableName}`);
+            
+            try {
+                const created = await this._supsis.table.createField(tableId, fieldData);
+                this._fieldMap[fieldKey] = created;
+                this._log('success', `Field created: ${fieldDef.name} -> ${created._id}`);
+            } catch (e) {
+                this._log('error', `Failed to create field ${fieldDef.name}:`, e.message);
+                throw new AppBuilderBuildError(
+                    `Failed to create field '${fieldDef.name}' in table '${tableName}'`,
+                    'fields',
+                    { field: fieldDef, error: e.message }
+                );
+            }
+        }
+    }
+
+    /**
+     * Convert name to API name (slug)
+     * @private
+     */
+    _toApiName(name) {
+        return name
+            .toLowerCase()
+            .replace(/ğ/g, 'g')
+            .replace(/ü/g, 'u')
+            .replace(/ş/g, 's')
+            .replace(/ı/g, 'i')
+            .replace(/ö/g, 'o')
+            .replace(/ç/g, 'c')
+            .replace(/[^a-z0-9]/g, '_')
+            .replace(/_+/g, '_')
+            .replace(/^_|_$/g, '');
+    }
+
+    /**
+     * Build modules
+     * @private
+     */
+    async _buildModules(template, options) {
+        this._log('phase', 'Building Modules');
+        
+        const modules = template.modules || [];
+        const appName = template.name;
+        
+        for (const moduleDef of modules) {
+            const uid = moduleDef.uid || `module.${moduleDef.apiName || this._toApiName(moduleDef.name)}`;
+            
+            // Resolve table UID to ID
+            const tableUid = moduleDef.table;
+            const table = this._tableMap[tableUid];
+            
+            if (!table) {
+                this._log('error', `Table not found for module '${moduleDef.name}': ${tableUid}`);
+                continue;
+            }
+            
+            // Check if module already exists
+            const existingModule = await this._findExistingModule(appName, uid);
+            
+            if (existingModule) {
+                if (options.skipExisting) {
+                    this._log('info', `Module '${moduleDef.name}' already exists, skipping...`);
+                    this._moduleMap[uid] = existingModule;
+                    continue;
+                }
+                
+                if (options.updateExisting) {
+                    if (options.dryRun) {
+                        this._log('info', `[DRY-RUN] Would update module: ${moduleDef.name}`);
+                    } else {
+                        this._log('info', `Updating module: ${moduleDef.name}`);
+                        const updated = await this._supsis.module.update(existingModule.moduleName, {
+                            displayName: moduleDef.name,
+                            description: this._generateDescription(appName, uid, moduleDef.description),
+                            icon: moduleDef.icon,
+                            settings: moduleDef.settings
+                        });
+                        this._moduleMap[uid] = updated;
+                    }
+                    continue;
+                }
+            }
+            
+            // Create new module
+            if (options.dryRun) {
+                this._log('info', `[DRY-RUN] Would create module: ${moduleDef.name}`);
+                this._moduleMap[uid] = { _id: `dry-run-${uid}`, displayName: moduleDef.name };
+            } else {
+                this._log('info', `Creating module: ${moduleDef.name} -> table ${table._id}`);
+                
+                const moduleData = {
+                    displayName: moduleDef.name,
+                    description: this._generateDescription(appName, uid, moduleDef.description),
+                    type: 'module',
+                    icon: moduleDef.icon || 'widgets',
+                    module: {
+                        table: table._id,
+                        settings: moduleDef.settings || {
+                            showInMainMenu: true,
+                            apiEnabled: true
+                        }
+                    }
+                };
+                
+                try {
+                    const created = await this._supsis.module.create(moduleData);
+                    this._moduleMap[uid] = created;
+                    this._log('success', `Module created: ${moduleDef.name} -> ${created._id}`);
+                } catch (e) {
+                    this._log('error', `Failed to create module ${moduleDef.name}:`, e.message);
+                    throw new AppBuilderBuildError(
+                        `Failed to create module '${moduleDef.name}'`,
+                        'modules',
+                        { module: moduleDef, error: e.message }
+                    );
+                }
+            }
+        }
+    }
+
+    /**
+     * Build cache entries
+     * @private
+     */
+    async _buildCache(template, options) {
+        this._log('phase', 'Building Cache Entries');
+        
+        const cache = template.cache || {};
+        const appName = template.name;
+        
+        for (const [key, value] of Object.entries(cache)) {
+            // Validate key starts with app name
+            if (!key.startsWith(appName)) {
+                this._log('warn', `Skipping cache key '${key}' - must start with app name '${appName}'`);
+                continue;
+            }
+            
+            if (options.dryRun) {
+                this._log('info', `[DRY-RUN] Would write cache: ${key}`);
+            } else {
+                this._log('info', `Writing cache: ${key}`);
+                
+                try {
+                    await this._supsis.cache.write(key, value, {
+                        type: 'public',
+                        dataType: this._inferCacheDataType(value)
+                        // No expiresAt = never expires
+                    });
+                    this._log('success', `Cache written: ${key}`);
+                } catch (e) {
+                    this._log('warn', `Failed to write cache ${key}:`, e.message);
+                }
+            }
+        }
+    }
+
+    /**
+     * Build seed data
+     * @private
+     */
+    async _buildSeed(template, options) {
+        this._log('phase', 'Building Seed Data');
+        
+        const seed = template.seed || [];
+        
+        for (const seedItem of seed) {
+            const moduleName = seedItem.module;
+            const uid = seedItem.uid;
+            
+            // Find module
+            let targetModule = null;
+            for (const [mUid, mod] of Object.entries(this._moduleMap)) {
+                if (mod.moduleName === moduleName || mod.apiName === moduleName) {
+                    targetModule = mod;
+                    break;
+                }
+            }
+            
+            if (!targetModule) {
+                // Try direct module name
+                try {
+                    targetModule = await this._supsis.module.getByName(moduleName);
+                } catch (e) {
+                    this._log('warn', `Module not found for seed: ${moduleName}`);
+                    continue;
+                }
+            }
+            
+            // Resolve any UID references in data
+            const resolvedData = this._resolveSeedDataUids(seedItem.data);
+            
+            if (options.dryRun) {
+                this._log('info', `[DRY-RUN] Would create seed record in ${moduleName}:`, resolvedData);
+                if (uid) {
+                    this._seedMap[uid] = { _id: `dry-run-${uid}`, ...resolvedData };
+                }
+            } else {
+                this._log('info', `Creating seed record in ${moduleName}`);
+                
+                try {
+                    const created = await this._supsis.module.createRecord(targetModule.moduleName || moduleName, resolvedData);
+                    
+                    if (uid) {
+                        this._seedMap[uid] = created;
+                    }
+                    
+                    this._log('success', `Seed record created: ${created._id}`);
+                } catch (e) {
+                    this._log('error', `Failed to create seed record in ${moduleName}:`, e.message);
+                }
+            }
+        }
+    }
+
+    /**
+     * Resolve UID references in seed data
+     * @private
+     */
+    _resolveSeedDataUids(data) {
+        if (!data || typeof data !== 'object') return data;
+        
+        const resolved = {};
+        
+        for (const [key, value] of Object.entries(data)) {
+            if (typeof value === 'string' && this._seedMap[value]) {
+                // This is a UID reference to a previous seed record
+                resolved[key] = this._seedMap[value]._id;
+            } else if (typeof value === 'object' && value !== null) {
+                resolved[key] = this._resolveSeedDataUids(value);
+            } else {
+                resolved[key] = value;
+            }
+        }
+        
+        return resolved;
+    }
+
+    /**
+     * Store build manifest in cache
+     * @private
+     */
+    async _storeBuildManifest(template, options) {
+        this._log('phase', 'Storing Build Manifest');
+        
+        const manifestKey = `${template.name}_manifest`;
+        
+        const manifest = {
+            name: template.name,
+            version: template.version,
+            description: template.description,
+            builtAt: new Date().toISOString(),
+            tables: Object.entries(this._tableMap).map(([uid, table]) => ({
+                uid,
+                id: table._id,
+                name: table.name
+            })),
+            modules: Object.entries(this._moduleMap).map(([uid, mod]) => ({
+                uid,
+                id: mod._id,
+                name: mod.displayName || mod.moduleName
+            })),
+            cacheKeys: Object.keys(template.cache || {}),
+            template: template
+        };
+        
+        if (options.dryRun) {
+            this._log('info', `[DRY-RUN] Would store manifest: ${manifestKey}`);
+        } else {
+            try {
+                await this._supsis.cache.write(manifestKey, manifest, {
+                    type: 'public',
+                    dataType: 'json'
+                });
+                this._log('success', `Manifest stored: ${manifestKey}`);
+            } catch (e) {
+                this._log('warn', `Failed to store manifest:`, e.message);
+            }
+        }
+        
+        return manifest;
+    }
+
+    /**
+     * Build application from template
+     * 
+     * @param {AppTemplate} template - Application template
+     * @param {BuildOptions} [options] - Build options
+     * @returns {Promise<BuildResult>} Build result
+     * 
+     * @example
+     * const result = await appBuilder.build({
+     *   name: 'team-note-app',
+     *   version: '1.0.0',
+     *   tables: [
+     *     {
+     *       name: 'Notes',
+     *       uid: 'table.notes',
+     *       fields: [
+     *         { name: 'Title', fieldType: 'text' },
+     *         { name: 'Content', fieldType: 'long-text' }
+     *       ]
+     *     }
+     *   ],
+     *   modules: [
+     *     { name: 'Notes', table: 'table.notes' }
+     *   ]
+     * });
+     */
+    async build(template, options) {
+        options = Object.assign({
+            dryRun: false,
+            verbose: true,
+            skipExisting: true,
+            updateExisting: true
+        }, options);
+        
+        this._verbose = options.verbose;
+        
+        // Reset state
+        this._uidMap = {};
+        this._tableMap = {};
+        this._fieldMap = {};
+        this._moduleMap = {};
+        this._seedMap = {};
+        this._pendingFields = [];
+        
+        this._log('phase', `Building Application: ${template.name} v${template.version}`);
+        
+        // Validate template
+        this._validateTemplate(template);
+        this._log('success', 'Template validation passed');
+        
+        const startTime = Date.now();
+        
+        try {
+            // Phase 1: Create tables
+            await this._buildTables(template, options);
+            
+            // Phase 2: Create fields (non-linked)
+            await this._buildFields(template, options);
+            
+            // Phase 3: Create pending linked-record fields
+            await this._buildPendingFields(template, options);
+            
+            // Phase 4: Create modules
+            await this._buildModules(template, options);
+            
+            // Phase 5: Write cache entries
+            await this._buildCache(template, options);
+            
+            // Phase 6: Insert seed data
+            await this._buildSeed(template, options);
+            
+            // Phase 7: Store build manifest
+            const manifest = await this._storeBuildManifest(template, options);
+            
+            const duration = Date.now() - startTime;
+            
+            this._log('phase', `Build Complete in ${duration}ms`);
+            
+            return {
+                success: true,
+                dryRun: options.dryRun,
+                duration,
+                manifest,
+                tables: this._tableMap,
+                fields: this._fieldMap,
+                modules: this._moduleMap,
+                seeds: this._seedMap
+            };
+            
+        } catch (error) {
+            this._log('error', 'Build failed:', error.message);
+            throw error;
+        }
+    }
+
+    /**
+     * Check if application has been built
+     * 
+     * @param {string} appName - Application name
+     * @param {string} [version] - Optional version to check
+     * @returns {Promise<boolean|Object>} True/manifest if exists, false otherwise
+     */
+    async exists(appName, version) {
+        const manifestKey = `${appName}_manifest`;
+        
+        try {
+            const manifest = await this._supsis.cache.read(manifestKey);
+            
+            if (!manifest) return false;
+            
+            if (version && manifest.version !== version) {
+                return false;
+            }
+            
+            return manifest;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    /**
+     * Delete application by name
+     * 
+     * @param {string} appName - Application name
+     * @returns {Promise<DeleteResult>} Delete result
+     */
+    async deleteWithAppName(appName) {
+        this._log('phase', `Deleting Application: ${appName}`);
+        
+        const manifest = await this.exists(appName);
+        
+        if (!manifest) {
+            throw new AppBuilderValidationError(`Application '${appName}' not found`);
+        }
+        
+        return await this._deleteWithManifest(manifest);
+    }
+
+    /**
+     * Delete application by template
+     * 
+     * @param {AppTemplate} template - Application template
+     * @returns {Promise<DeleteResult>} Delete result
+     */
+    async deleteWithTemplate(template) {
+        this._log('phase', `Deleting Application from Template: ${template.name}`);
+        
+        // Build a manifest-like structure from template
+        const manifest = {
+            name: template.name,
+            tables: (template.tables || []).map(t => ({ uid: t.uid })),
+            modules: (template.modules || []).map(m => ({ 
+                uid: m.uid || `module.${m.apiName || this._toApiName(m.name)}`
+            })),
+            cacheKeys: Object.keys(template.cache || {})
+        };
+        
+        return await this._deleteWithManifest(manifest);
+    }
+
+    /**
+     * Delete application using manifest
+     * @private
+     */
+    async _deleteWithManifest(manifest) {
+        const result = {
+            deletedTables: [],
+            deletedModules: [],
+            deletedCacheKeys: [],
+            errors: []
+        };
+        
+        const appName = manifest.name;
+        
+        // Delete modules first
+        for (const mod of (manifest.modules || [])) {
+            try {
+                const existing = await this._findExistingModule(appName, mod.uid);
+                if (existing) {
+                    await this._supsis.module.delete(existing._id);
+                    result.deletedModules.push(mod.uid);
+                    this._log('success', `Deleted module: ${mod.uid}`);
+                }
+            } catch (e) {
+                result.errors.push({ type: 'module', uid: mod.uid, error: e.message });
+                this._log('error', `Failed to delete module ${mod.uid}:`, e.message);
+            }
+        }
+        
+        // Delete tables
+        for (const table of (manifest.tables || [])) {
+            try {
+                const existing = await this._findExistingTable(appName, table.uid);
+                if (existing) {
+                    await this._supsis.table.delete(existing._id);
+                    result.deletedTables.push(table.uid);
+                    this._log('success', `Deleted table: ${table.uid}`);
+                }
+            } catch (e) {
+                result.errors.push({ type: 'table', uid: table.uid, error: e.message });
+                this._log('error', `Failed to delete table ${table.uid}:`, e.message);
+            }
+        }
+        
+        // Delete cache entries
+        for (const key of (manifest.cacheKeys || [])) {
+            try {
+                await this._supsis.cache.deleteByPattern(key);
+                result.deletedCacheKeys.push(key);
+                this._log('success', `Deleted cache: ${key}`);
+            } catch (e) {
+                result.errors.push({ type: 'cache', key, error: e.message });
+                this._log('warn', `Failed to delete cache ${key}:`, e.message);
+            }
+        }
+        
+        // Delete manifest
+        try {
+            await this._supsis.cache.deleteByPattern(`${appName}_manifest`);
+            this._log('success', `Deleted manifest: ${appName}_manifest`);
+        } catch (e) {
+            this._log('warn', `Failed to delete manifest:`, e.message);
+        }
+        
+        this._log('phase', 'Delete Complete');
+        
+        return result;
+    }
+}
+
+// ==================== TYPE DEFINITIONS ====================
+
+/**
+ * Application template
+ * @typedef {Object} AppTemplate
+ * @property {string} name - Application name (used for cache keys prefix)
+ * @property {string} version - Semantic version (e.g., '1.0.0')
+ * @property {string} [description] - Application description
+ * @property {TableTemplate[]} [tables] - Table definitions
+ * @property {ModuleTemplate[]} [modules] - Module definitions
+ * @property {Object.<string, *>} [cache] - Cache key-value pairs (keys must start with app name)
+ * @property {SeedItem[]} [seed] - Seed data items
+ */
+
+/**
+ * Table template
+ * @typedef {Object} TableTemplate
+ * @property {string} name - Table name
+ * @property {string} uid - Unique identifier (e.g., 'table.notes')
+ * @property {string} [description] - Table description
+ * @property {string} [icon] - Material icon name
+ * @property {FieldTemplate[]} [fields] - Field definitions
+ */
+
+/**
+ * Field template
+ * @typedef {Object} FieldTemplate
+ * @property {string} name - Field name
+ * @property {string} [apiName] - API name (auto-generated if not provided)
+ * @property {string} fieldType - Field type (see FieldType)
+ * @property {string} [icon] - Material icon name
+ * @property {'left'|'center'|'right'} [alignment] - Text alignment
+ * @property {*} [defaultValue] - Default value
+ * @property {Object} [options] - Field options (type-specific)
+ */
+
+/**
+ * Module template
+ * @typedef {Object} ModuleTemplate
+ * @property {string} name - Module display name
+ * @property {string} [apiName] - API name (auto-generated if not provided)
+ * @property {string} [uid] - Unique identifier
+ * @property {string} table - Table UID reference
+ * @property {string} [description] - Module description
+ * @property {string} [icon] - Material icon name
+ * @property {Object} [settings] - Module settings
+ * @property {boolean} [settings.showInMainMenu=true] - Show in main menu
+ * @property {boolean} [settings.apiEnabled=true] - Enable API access
+ */
+
+/**
+ * Seed data item
+ * @typedef {Object} SeedItem
+ * @property {string} module - Module name (apiName)
+ * @property {Object} data - Record data
+ * @property {string} [uid] - UID for referencing in other seed items
+ */
+
+/**
+ * Build options
+ * @typedef {Object} BuildOptions
+ * @property {boolean} [dryRun=false] - Preview changes without executing
+ * @property {boolean} [verbose=true] - Enable detailed logging
+ * @property {boolean} [skipExisting=true] - Skip existing resources
+ * @property {boolean} [updateExisting=true] - Update existing resources
+ */
+
+/**
+ * Build result
+ * @typedef {Object} BuildResult
+ * @property {boolean} success - Build success status
+ * @property {boolean} dryRun - Was this a dry run
+ * @property {number} duration - Build duration in ms
+ * @property {Object} manifest - Build manifest
+ * @property {Object} tables - Created/updated tables
+ * @property {Object} fields - Created/updated fields
+ * @property {Object} modules - Created/updated modules
+ * @property {Object} seeds - Created seed records
+ */
+
+/**
+ * Delete result
+ * @typedef {Object} DeleteResult
+ * @property {string[]} deletedTables - Deleted table UIDs
+ * @property {string[]} deletedModules - Deleted module UIDs
+ * @property {string[]} deletedCacheKeys - Deleted cache keys
+ * @property {Object[]} errors - Errors encountered
+ */
+
 /**
  * Supsis JS SDK
  * 
@@ -4217,6 +5851,8 @@ class SupsisModuleAPI {
  */
 
 exports.AICall = AICall;
+exports.AppBuilderBuildError = AppBuilderBuildError;
+exports.AppBuilderValidationError = AppBuilderValidationError;
 exports.Asset = Asset;
 exports.BaseModule = BaseModule;
 exports.Cache = Cache;
@@ -4230,6 +5866,7 @@ exports.Module = Module;
 exports.SDK_VERSION = SDK_VERSION;
 exports.Site = Site;
 exports.SupsisAPIError = SupsisAPIError;
+exports.SupsisAppBuilder = SupsisAppBuilder;
 exports.SupsisJS = SupsisJS;
 exports.SupsisModuleAPI = SupsisModuleAPI;
 exports.Table = Table;