plusui-native-bindgen 0.1.49 → 0.1.52

package/src/advanced-bindgen.js

@@ -1,743 +1,704 @@
 #!/usr/bin/env node
 
-import { readdir, readFile, writeFile, mkdir, stat } from 'fs/promises';
+import { mkdir, readFile, writeFile, readdir } from 'fs/promises';
 import { existsSync } from 'fs';
-import { join, relative, basename, resolve } from 'path';
-
-const IGNORE_DIRS = new Set([
-    'node_modules',
-    '.git',
-    '.svn',
-    '.hg',
-    '.next',
-    '.nuxt',
-    '.plusui',
-    'build',
-    'dist',
-    'out',
-    '.idea',
-    '.vscode',
-]);
-
-const WEB_IO = new Set(['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts', '.html']);
-const CPP_IO = new Set(['.h', '.hpp', '.hh', '.hxx', '.cpp', '.cc', '.cxx']);
-
-const CORE_SYMBOL_TO_FEATURE = {
-    app: 'App',
-    browser: 'Browser',
-    router: 'Browser',
-    clipboard: 'Clipboard',
-    display: 'Display',
-    keyboard: 'Keyboard',
-    menu: 'Menu',
-    tray: 'Tray',
-    webgpu: 'WebGPU',
-    webview: 'WebView',
-    window: 'Window',
-    event: 'Event',
-    events: 'Event',
+import { join, resolve } from 'path';
+
+const CONNECT_SCHEMA_PATHS = [
+  'Core/Features/Connection/schema/connection.schema',
+  'Features/Connection/schema/connection.schema',
+  'connection.schema',
+];
+
+const LEGACY_SCHEMA_PATHS = [
+  'bridge.d.ts',
+  'src/bridge.d.ts',
+  'Core/bridge.d.ts',
+];
+
+// NEW: Scan for inline annotations in C++ files
+const CPP_PATTERNS = {
+  call: /CONNECT_CALL\s*\(\s*(\w+)\s*,\s*([^,]+)\s*,\s*([^)]+)\s*\)/g,
+  fire: /CONNECT_FIRE\s*\(\s*(\w+)\s*,\s*([^)]+)\s*\)/g,
+  event: /CONNECT_EVENT\s*\(\s*(\w+)\s*,\s*([^)]+)\s*\)/g,
+  stream: /CONNECT_STREAM\s*\(\s*(\w+)\s*,\s*([^)]+)\s*\)/g,
+  channel: /CONNECT_CHANNEL\s*\(\s*(\w+)\s*,\s*([^)]+)\s*\)/g,
 };
 
-function isIgnoredPathSegment(name) {
-    return IGNORE_DIRS.has(name);
-}
-
-function getExtension(fileName) {
-    const index = fileName.lastIndexOf('.');
-    return index >= 0 ? fileName.slice(index).toLowerCase() : '';
-}
-
-async function walkFiles(rootDir, predicate, out = []) {
-    if (!existsSync(rootDir)) {
-        return out;
-    }
-
-    const entries = await readdir(rootDir, { withFileTypes: true });
-    for (const entry of entries) {
-        const fullPath = join(rootDir, entry.name);
-
-        if (entry.isDirectory()) {
-            if (isIgnoredPathSegment(entry.name)) {
-                continue;
-            }
-
-            // Never walk inside installed core package for custom-header scan
-            const normalized = fullPath.replace(/\\/g, '/').toLowerCase();
-            if (normalized.includes('/node_modules/plusui-native-core/')) {
-                continue;
-            }
-
-            await walkFiles(fullPath, predicate, out);
-            continue;
-        }
-
-        if (entry.isFile() && predicate(fullPath, entry.name)) {
-            out.push(fullPath);
-        }
-    }
+const LEGACY_KIND_MAP = {
+  call: 'call',
+  fire: 'fire',
+  event: 'event',
+};
 
-    return out;
+function toPascalCase(value) {
+  return value
+    .replace(/[^a-zA-Z0-9]+/g, ' ')
+    .split(' ')
+    .filter(Boolean)
+    .map((part) => part[0].toUpperCase() + part.slice(1))
+    .join('');
 }
 
-function normalizeCppType(rawType) {
-    const cleaned = rawType.trim().toLowerCase();
-
-    if (cleaned === 'void') return 'void';
-    if (cleaned === 'bool' || cleaned === 'boolean') return 'boolean';
-    if (cleaned === 'int' || cleaned === 'int32_t' || cleaned === 'int64_t' || cleaned === 'float' || cleaned === 'double') return 'number';
-    if (cleaned.includes('std::string') || cleaned === 'string') return 'string';
-    if (cleaned.includes('json') || cleaned.includes('nlohmann::json')) return 'any';
-    return 'any';
+function parseFieldMap(source) {
+  const text = source.trim();
+  if (!text) {
+    return [];
+  }
+
+  return text
+    .split(',')
+    .map((chunk) => chunk.trim())
+    .filter(Boolean)
+    .map((chunk) => {
+      const match = chunk.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*([a-zA-Z_][a-zA-Z0-9_<>|\[\]]*)$/);
+      if (!match) {
+        throw new Error(`Invalid field syntax: "${chunk}"`);
+      }
+      return { name: match[1], type: match[2] };
+    });
 }
 
-function pascalCase(value) {
-    return value
-        .split(/[^a-zA-Z0-9]+/)
-        .filter(Boolean)
-        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
-        .join('');
+function normalizeSource(content) {
+  return content
+    .replace(/\r/g, '\n')
+    .replace(/#.*$/gm, '')
+    .replace(/\/\/.*$/gm, '')
+    .replace(/\s+/g, ' ')
+    .trim();
 }
 
-function camelCase(value) {
-    const p = pascalCase(value);
-    return p ? p.charAt(0).toLowerCase() + p.slice(1) : value;
+function parseConnectSchema(content, schemaPath) {
+  const normalized = normalizeSource(content);
+  const pattern = /connect\s+([a-zA-Z_][a-zA-Z0-9_]*)\s+(call|fire|event|stream|channel)\s+in\s*\{([^}]*)\}(?:\s+out\s*\{([^}]*)\})?/g;
+  const methods = [];
+
+  let match = null;
+  while ((match = pattern.exec(normalized)) !== null) {
+    const name = match[1];
+    const kind = match[2];
+    const inFields = parseFieldMap(match[3] || '');
+    const outFields = parseFieldMap(match[4] || '');
+
+    methods.push({
+      name,
+      kind,
+      params: inFields,
+      result: outFields,
+    });
+  }
+
+  if (methods.length === 0) {
+    throw new Error(`No connect entries found in ${schemaPath}`);
+  }
+
+  return methods;
 }
 
-function findCoreFeaturesDir(projectRoot) {
-    const candidates = [
-        join(projectRoot, 'node_modules', 'plusui-native-core', 'Core', 'Features'),
-        join(projectRoot, 'node_modules', 'plusui-native-core', 'Features'),
-        join(projectRoot, 'Core', 'Features'),
-    ];
-
-    for (const dir of candidates) {
-        if (existsSync(dir)) {
-            return dir;
-        }
+function parseLegacyBridgeDts(content) {
+  const linesRaw = content.split('\n');
+  let insideBridge = false;
+  let braceCount = 0;
+  const bridgeBodyLines = [];
+
+  for (const line of linesRaw) {
+    const trimmed = line.trim();
+    if (!insideBridge) {
+      if (trimmed.match(/(?:export\s+)?interface\s+Bridge\s*{/)) {
+        insideBridge = true;
+        braceCount = 1;
+        const opens = (line.match(/{/g) || []).length;
+        const closes = (line.match(/}/g) || []).length;
+        braceCount += opens - 1 - closes;
+      }
+      continue;
     }
 
-    return null;
-}
+    const opens = (line.match(/{/g) || []).length;
+    const closes = (line.match(/}/g) || []).length;
+    braceCount += opens - closes;
 
-function collectNamedImports(content) {
-    const named = new Set();
-
-    const importRegex = /import\s*\{([^}]+)\}\s*from\s*['"]plusui-native-core['"]/g;
-    let match;
-    while ((match = importRegex.exec(content)) !== null) {
-        const names = match[1]
-            .split(',')
-            .map(part => part.trim())
-            .filter(Boolean)
-            .map(part => part.split(/\s+as\s+/i)[0].trim());
-        for (const name of names) {
-            named.add(name);
-        }
+    if (braceCount === 0) {
+      break;
     }
 
-    const requireRegex = /(?:const|let|var)\s*\{([^}]+)\}\s*=\s*require\(\s*['"]plusui-native-core['"]\s*\)/g;
-    while ((match = requireRegex.exec(content)) !== null) {
-        const names = match[1]
-            .split(',')
-            .map(part => part.trim())
-            .filter(Boolean)
-            .map(part => part.split(':')[0].trim());
-        for (const name of names) {
-            named.add(name);
-        }
+    bridgeBodyLines.push(line);
+  }
+
+  const lines = bridgeBodyLines
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith('//') && !line.startsWith('/*') && !line.startsWith('*'));
+
+  const methods = [];
+  for (const line of lines) {
+    const propMatch = line.match(/^(\w+)\s*:\s*(.+);$/);
+    if (propMatch && !line.includes('(')) {
+      methods.push({
+        name: propMatch[1],
+        kind: 'event',
+        params: [{ name: 'value', type: propMatch[2].trim() }],
+        result: [],
+      });
+      continue;
     }
 
-    return named;
-}
-
-function collectNamespaceImportAliases(content) {
-    const aliases = new Set();
-    const nsRegex = /import\s+\*\s+as\s+(\w+)\s+from\s+['"]plusui-native-core['"]/g;
-    let match;
-    while ((match = nsRegex.exec(content)) !== null) {
-        aliases.add(match[1]);
+    const methodMatch = line.match(/^(\w+)\s*\(([^)]*)\)\s*:\s*(.+);$/);
+    if (!methodMatch) {
+      continue;
     }
-    return aliases;
-}
-
-function detectUsedCoreFeaturesFromContent(content) {
-    const used = new Set();
 
-    for (const importedName of collectNamedImports(content)) {
-        const feature = CORE_SYMBOL_TO_FEATURE[importedName.toLowerCase()];
-        if (feature) {
-            used.add(feature);
-        }
+    const name = methodMatch[1];
+    const rawParams = methodMatch[2];
+    const returnType = methodMatch[3].trim();
+
+    const params = rawParams
+      ? rawParams
+          .split(',')
+          .map((p) => p.trim())
+          .filter(Boolean)
+          .map((p) => {
+            const [paramName, paramType] = p.split(':').map((value) => value.trim());
+            return { name: paramName, type: paramType || 'unknown' };
+          })
+      : [];
+
+    if (name.startsWith('on')) {
+      methods.push({ name, kind: 'event', params, result: [] });
+      continue;
     }
 
-    for (const alias of collectNamespaceImportAliases(content)) {
-        const nsUsageRegex = new RegExp(`\\b${alias}\\.(\\w+)\\b`, 'g');
-        let match;
-        while ((match = nsUsageRegex.exec(content)) !== null) {
-            const symbol = match[1].toLowerCase();
-            const feature = CORE_SYMBOL_TO_FEATURE[symbol];
-            if (feature) {
-                used.add(feature);
-            }
-        }
+    if (returnType.startsWith('Promise<')) {
+      const resultType = returnType.replace(/^Promise<(.+)>$/, '$1');
+      methods.push({
+        name,
+        kind: 'call',
+        params,
+        result: [{ name: 'value', type: resultType }],
+      });
+      continue;
     }
 
-    const directUsageRegex = /\b(app|browser|router|clipboard|display|keyboard|menu|tray|webgpu|webview|window|event|events)\s*\./g;
-    let usageMatch;
-    while ((usageMatch = directUsageRegex.exec(content)) !== null) {
-        const feature = CORE_SYMBOL_TO_FEATURE[usageMatch[1].toLowerCase()];
-        if (feature) {
-            used.add(feature);
-        }
-    }
+    methods.push({ name, kind: 'fire', params, result: [] });
+  }
 
-    return used;
+  return methods;
 }
 
-async function detectUsedCoreFeatures(projectRoot) {
-    const sourceFiles = await walkFiles(
-        projectRoot,
-        (filePath, fileName) => {
-            const ext = getExtension(fileName);
-            return WEB_IO.has(ext) || CPP_IO.has(ext);
-        }
-    );
-
-    const usedFeatures = new Set();
-    for (const filePath of sourceFiles) {
-        const content = await readFile(filePath, 'utf-8').catch(() => '');
-        if (!content) continue;
-
-        for (const feature of detectUsedCoreFeaturesFromContent(content)) {
-            usedFeatures.add(feature);
-        }
+async function loadSchema(projectRoot) {
+  for (const relPath of CONNECT_SCHEMA_PATHS) {
+    const fullPath = join(projectRoot, relPath);
+    if (!existsSync(fullPath)) {
+      continue;
     }
 
-    return usedFeatures;
-}
-
-async function parseCoreFeatureMethods(coreFeaturesDir, usedFeatures) {
-    const coreMethods = new Map();
+    const content = await readFile(fullPath, 'utf-8');
+    const methods = parseConnectSchema(content, fullPath);
+    return { methods, schemaPath: fullPath, schemaKind: 'connect' };
+  }
 
-    if (!coreFeaturesDir || usedFeatures.size === 0) {
-        return coreMethods;
+  for (const relPath of LEGACY_SCHEMA_PATHS) {
+    const fullPath = join(projectRoot, relPath);
+    if (!existsSync(fullPath)) {
+      continue;
     }
 
-    for (const featureFolder of usedFeatures) {
-        const featureDir = join(coreFeaturesDir, featureFolder);
-        if (!existsSync(featureDir)) {
-            continue;
-        }
-
-        const tsFiles = await walkFiles(
-            featureDir,
-            (filePath, fileName) => WEB_IO.has(getExtension(fileName))
-        );
-
-        const methods = new Set();
-        for (const tsFile of tsFiles) {
-            const content = await readFile(tsFile, 'utf-8').catch(() => '');
-            if (!content) continue;
-
-            const invokeRegex = /(?:invoke|invokeFn)\(\s*['"]([a-zA-Z0-9_]+)\.([a-zA-Z0-9_]+)['"]/g;
-            let match;
-            while ((match = invokeRegex.exec(content)) !== null) {
-                methods.add(match[2]);
-            }
-        }
-
-        coreMethods.set(featureFolder, Array.from(methods).sort((a, b) => a.localeCompare(b)));
-    }
+    const content = await readFile(fullPath, 'utf-8');
+    const methods = parseLegacyBridgeDts(content);
+    return { methods, schemaPath: fullPath, schemaKind: 'legacy' };
+  }
 
-    return coreMethods;
+  throw new Error(
+    `No schema found. Expected one of: ${CONNECT_SCHEMA_PATHS.concat(LEGACY_SCHEMA_PATHS).join(', ')}`
+  );
 }
 
-async function parseCustomBackendBindings(projectRoot) {
-    const backendFiles = await walkFiles(
-        projectRoot,
-        (filePath, fileName) => CPP_IO.has(getExtension(fileName))
-    );
-
-    const bindingSources = [];
-
-    for (const backendPath of backendFiles) {
-        const content = await readFile(backendPath, 'utf-8').catch(() => '');
-        if (!content) continue;
-
-        // Unified PLUSUI_BIND macro parsing
-        // Format: PLUSUI_BIND(name, returnType, ...paramTypes)
-        const bindRegex = /PLUSUI_BIND\(\s*(\w+)\s*,\s*([^,\)]+)\s*((?:,\s*[^,\)]+\s*)*)\)/g;
-
-        const bindings = [];
-
-        let bindMatch;
-        while ((bindMatch = bindRegex.exec(content)) !== null) {
-            const name = bindMatch[1];
-            const returnType = normalizeCppType(bindMatch[2]);
-            const params = (bindMatch[3] || '')
-                .split(',')
-                .map(token => token.trim())
-                .filter(Boolean)
-                .map((paramType, index) => ({
-                    name: `arg${index}`,
-                    type: normalizeCppType(paramType),
-                }));
-
-            // Auto-detect direction based on naming convention
-            // Methods starting with "on" are events (backend → frontend)
-            // Otherwise they're methods (frontend → backend)
-            const isEvent = name.startsWith('on') && returnType === 'void';
-            const kind = isEvent ? 'event' : 'method';
-
-            bindings.push({ name, returnType, params, kind });
-        }
-
-        if (bindings.length === 0) {
-            continue;
-        }
-
-        const baseName = basename(backendPath).replace(/\.(hpp|h|hh|hxx|cpp|cc|cxx)$/i, '');
-        
-        // Separate into operations and events for compatibility
-        const operations = bindings.filter(b => b.kind === 'method');
-        const events = bindings.filter(b => b.kind === 'event').map(b => ({
-            name: b.name,
-            dataType: b.params[0]?.type || 'any'
-        }));
-
-        bindingSources.push({
-            name: baseName,
-            sourcePath: backendPath,
-            operations,
-            events,
-        });
-    }
-
-    return bindingSources;
+function tsType(type) {
+  if (type === 'string' || type === 'number' || type === 'boolean' || type === 'unknown') {
+    return type;
+  }
+  return 'unknown';
 }
 
-function generateCppBindings(customBindings, coreFeatureMethods) {
-    const lines = [];
-    lines.push('// Auto-generated by plusui-bindgen');
-    lines.push('// App-scoped binding metadata (no core/package files are modified)');
-    lines.push('#pragma once');
-    lines.push('');
-    lines.push('#include <string>');
-    lines.push('#include <vector>');
-    lines.push('');
-    lines.push('namespace plusui::bindings {');
-    lines.push('');
-    lines.push('struct BindingEntry {');
-    lines.push('    const char* source;');
-    lines.push('    const char* feature;');
-    lines.push('    const char* method;');
-    lines.push('};');
-    lines.push('');
-    lines.push('inline const std::vector<BindingEntry>& getBindingEntries() {');
-    lines.push('    static const std::vector<BindingEntry> entries = {');
-
-    for (const [featureName, methods] of coreFeatureMethods.entries()) {
-        for (const methodName of methods) {
-            lines.push(`        {"core", "${featureName}", "${methodName}"},`);
-        }
-    }
-
-    for (const bindingSource of customBindings) {
-        for (const operation of bindingSource.operations) {
-            lines.push(`        {"custom", "${bindingSource.name}", "${operation.name}"},`);
-        }
-    }
+function cppType(type) {
+  if (type === 'string') {
+    return 'std::string';
+  }
+  if (type === 'number') {
+    return 'double';
+  }
+  if (type === 'boolean') {
+    return 'bool';
+  }
+  return 'nlohmann::json';
+}
 
-    lines.push('    };');
-    lines.push('    return entries;');
-    lines.push('}');
-    lines.push('');
-    lines.push('} // namespace plusui::bindings');
-    lines.push('');
+function emitTsTypeAlias(aliasName, fields) {
+  if (fields.length === 0) {
+    return `export type ${aliasName} = {};`;
+  }
 
-    return lines.join('\n');
+  const body = fields.map((field) => `  ${field.name}: ${tsType(field.type)};`).join('\n');
+  return `export type ${aliasName} = {\n${body}\n};`;
 }
 
-function generateCoreTsClass(featureName, methods) {
-    const className = `${pascalCase(featureName)}Bindings`;
-    const instanceName = camelCase(featureName);
-    const lines = [];
+function generateConnectionTs(methods) {
+  const lines = [];
+  lines.push('/**');
+  lines.push(' * Auto-generated by plusui-bindgen');
+  lines.push(' * DO NOT EDIT - Changes will be overwritten');
+  lines.push(' * Generated from: connection.schema');
+  lines.push(' */');
+  lines.push('import { connection } from "../connection";');
+  lines.push('');
+
+  // Generate type definitions
+  lines.push('// ============================================');
+  lines.push('// Type Definitions');
+  lines.push('// ============================================');
+  lines.push('');
+  
+  for (const method of methods) {
+    const base = toPascalCase(method.name);
     
-    lines.push(`/**`);
-    lines.push(` * ${featureName} - Native Core Bindings`);
-    lines.push(` */`);
-    lines.push(`export class ${className} {`);
+    // Input types
+    if (method.params.length > 0) {
+      lines.push(emitTsTypeAlias(`${base}In`, method.params));
+    } else {
+      lines.push(`export type ${base}In = void;`);
+    }
     
-    for (const method of methods) {
-        lines.push('');
-        lines.push(`  /** Core method: ${featureName}.${method} */`);
-        lines.push(`  async ${method}(...args: unknown[]): Promise<unknown> {`);
-        lines.push(`    return invoke("${featureName.toLowerCase()}.${method}", args);`);
-        lines.push('  }');
+    // Output types for calls
+    if (method.kind === 'call') {
+      if (method.result.length > 0) {
+        lines.push(emitTsTypeAlias(`${base}Out`, method.result));
+      } else {
+        lines.push(`export type ${base}Out = void;`);
+      }
     }
     
-    if (methods.length === 0) {
-        lines.push('  // No methods discovered');
+    // Data types for events/streams/channels
+    if (method.kind === 'event' || method.kind === 'stream' || method.kind === 'channel') {
+      if (method.params.length > 0) {
+        lines.push(emitTsTypeAlias(`${base}Data`, method.params));
+      } else {
+        lines.push(`export type ${base}Data = void;`);
+      }
     }
     
-    lines.push('}');
     lines.push('');
-    return { className, instanceName, code: lines.join('\n') };
-}
-
-function generateCustomTsClass(bindingSource) {
-    const className = `${pascalCase(bindingSource.name)}Bindings`;
-    const instanceName = camelCase(bindingSource.name);
-    const lines = [];
+  }
+
+  lines.push('// ============================================');
+  lines.push('// Connection API');
+  lines.push('// ============================================');
+  lines.push('');
+  lines.push('/**');
+  lines.push(' * Unified connection API for frontend <-> backend communication');
+  lines.push(' * - call: Request/response (async)');
+  lines.push(' * - fire: One-way to backend');
+  lines.push(' * - events: Listen to backend notifications');
+  lines.push(' * - streams: Subscribe to backend data streams');
+  lines.push(' * - channels: Bidirectional pub/sub');
+  lines.push(' */');
+  lines.push('export const connect = {');
+  
+  for (const method of methods) {
+    const base = toPascalCase(method.name);
     
-    lines.push(`/**`);
-    lines.push(` * ${bindingSource.name} - Custom Bindings`);
-    lines.push(` * Generated from: ${basename(bindingSource.sourcePath)}`);
-    lines.push(` */`);
-    lines.push(`export class ${className} {`);
-
-    // Generate methods (frontend → backend calls)
-    for (const operation of bindingSource.operations) {
-        const params = operation.params.map((param, idx) => `${param.name}: ${param.type === 'void' ? 'unknown' : param.type}`).join(', ');
-        const argNames = operation.params.map(param => param.name).join(', ');
-        const returnType = operation.returnType === 'void' ? 'void' : operation.returnType;
-        const promiseType = `Promise<${returnType}>`;
-
-        lines.push('');
-        lines.push(`  /** Call backend method: ${operation.name} */`);
-        lines.push(`  async ${operation.name}(${params}): ${promiseType} {`);
-        if (argNames) {
-            lines.push(`    return invoke("${bindingSource.name}.${operation.name}", [${argNames}]) as ${promiseType};`);
-        } else {
-            lines.push(`    return invoke("${bindingSource.name}.${operation.name}", []) as ${promiseType};`);
-        }
-        lines.push('  }');
+    if (method.kind === 'call') {
+      const hasParams = method.params.length > 0;
+      const hasResult = method.result.length > 0;
+      const paramType = hasParams ? `${base}In` : 'void';
+      const returnType = hasResult ? `${base}Out` : 'void';
+      
+      lines.push('');
+      lines.push(`  /** [CALL] ${method.name} - Request/response */`);
+      if (hasParams) {
+        lines.push(`  ${method.name}: (args: ${paramType}): Promise<${returnType}> => `);
+        lines.push(`    connection.call<${returnType}, ${paramType}>("${method.name}", args),`);
+      } else {
+        lines.push(`  ${method.name}: (): Promise<${returnType}> => `);
+        lines.push(`    connection.call<${returnType}, Record<string, never>>("${method.name}", {}),`);
+      }
+      continue;
     }
 
-    // Generate event listeners (backend → frontend events)
-    for (const eventItem of bindingSource.events) {
-        lines.push('');
-        lines.push(`  /** Listen to backend event: ${eventItem.name} */`);
-        lines.push(`  ${eventItem.name}(handler: (data: ${eventItem.dataType}) => void): () => void {`);
-        lines.push(`    const eventName = "plusui:binding:${bindingSource.name}.${eventItem.name}";`);
-        lines.push('    const listener = (e: Event) => {');
-        lines.push(`      handler((e as CustomEvent<${eventItem.dataType}>).detail);`);
-        lines.push('    };');
-        lines.push('    window.addEventListener(eventName, listener);');
-        lines.push('    return () => window.removeEventListener(eventName, listener);');
-        lines.push('  }');
+    if (method.kind === 'fire') {
+      const hasParams = method.params.length > 0;
+      const paramType = hasParams ? `${base}In` : 'void';
+      
+      lines.push('');
+      lines.push(`  /** [FIRE] ${method.name} - One-way to backend */`);
+      if (hasParams) {
+        lines.push(`  ${method.name}: (args: ${paramType}): void => `);
+        lines.push(`    connection.fire<${paramType}>("${method.name}", args),`);
+      } else {
+        lines.push(`  ${method.name}: (): void => `);
+        lines.push(`    connection.fire("${method.name}", {}),`);
+      }
+      continue;
     }
 
-    if (bindingSource.operations.length === 0 && bindingSource.events.length === 0) {
-        lines.push('  // No bindings discovered');
+    if (method.kind === 'event') {
+      lines.push('');
+      lines.push(`  /** [EVENT] ${method.name} - Listen to backend notification */`);
+      lines.push(`  ${method.name}: (callback: (data: ${base}Data) => void): (() => void) => `);
+      lines.push(`    connection.on<${base}Data>("${method.name}", callback),`);
+      continue;
     }
 
-    lines.push('}');
-    lines.push('');
-    return { className, instanceName, code: lines.join('\n') };
-}
+    if (method.kind === 'stream') {
+      lines.push('');
+      lines.push(`  /** [STREAM] ${method.name} - Subscribe to backend data stream */`);
+      lines.push(`  ${method.name}: {`);
+      lines.push(`    subscribe: (callback: (data: ${base}Data) => void): (() => void) => `);
+      lines.push(`      connection.stream<${base}Data>("${method.name}").subscribe(callback),`);
+      lines.push('  },');
+      continue;
+    }
 
-function generateTsBindings(coreFeatureMethods, customBindings) {
-    const lines = [];
-    lines.push('/**');
-    lines.push(' * PlusUI Generated Bindings');
-    lines.push(' * Auto-generated by plusui-bindgen');
-    lines.push(' * ');
-    lines.push(' * Usage:');
-    lines.push(' *   import { plusui } from "./bindings.gen";');
-    lines.push(' *   ');
-    lines.push(' *   // Call backend methods');
-    lines.push(' *   await plusui.myFeature.myMethod(args);');
-    lines.push(' *   ');
-    lines.push(' *   // Listen to backend events');
-    lines.push(' *   plusui.myFeature.onSomeEvent((data) => { ... });');
-    lines.push(' */');
-    lines.push('');
-    lines.push('// Binding bridge to native layer');
-    lines.push('type InvokeFn = (method: string, args?: unknown[]) => Promise<unknown>;');
-    lines.push('');
-    lines.push('function getInvoke(): InvokeFn {');
-    lines.push('  const w = typeof window !== "undefined" ? window as any : globalThis as any;');
-    lines.push('  if (typeof w.__invoke__ !== "function") {');
-    lines.push('    throw new Error("PlusUI binding bridge (__invoke__) not available");');
-    lines.push('  }');
-    lines.push('  return w.__invoke__;');
-    lines.push('}');
-    lines.push('');
-    lines.push('async function invoke(method: string, args: unknown[] = []): Promise<unknown> {');
-    lines.push('  return getInvoke()(method, args);');
-    lines.push('}');
-    lines.push('');
+    if (method.kind === 'channel') {
+      lines.push('');
+      lines.push(`  /** [CHANNEL] ${method.name} - Bidirectional pub/sub */`);
+      lines.push(`  ${method.name}: {`);
+      lines.push(`    subscribe: (callback: (data: ${base}Data) => void): (() => void) => `);
+      lines.push(`      connection.channel<${base}Data>("${method.name}").subscribe(callback),`);
+      lines.push(`    publish: (data: ${base}Data): void => `);
+      lines.push(`      connection.channel<${base}Data>("${method.name}").publish(data),`);
+      lines.push('  },');
+    }
+  }
+  
+  lines.push('};');
 
-    const bindingEntries = [];
-    const bindingExports = [];
+  lines.push('');
+  lines.push('// Legacy export for backwards compatibility');
+  lines.push('export const bindings = connect;');
+  lines.push('export default connect;');
+  lines.push('');
 
-    // Generate native core feature bindings
-    for (const [featureName, methods] of coreFeatureMethods.entries()) {
-        const generated = generateCoreTsClass(featureName, methods);
-        lines.push(generated.code);
-        bindingEntries.push(`  ${generated.instanceName}: new ${generated.className}(),`);
-        bindingExports.push(generated.instanceName);
+  return lines.join('\n');
+}
+
+function emitCppStruct(structName, fields) {
+  if (fields.length === 0) {
+    return `struct ${structName} {};`;
+  }
+
+  const lines = [];
+  lines.push(`struct ${structName} {`);
+  for (const field of fields) {
+    lines.push(`  ${cppType(field.type)} ${field.name};`);
+  }
+  
+  // Add from_json helper
+  lines.push('');
+  lines.push('  static ' + structName + ' from_json(const nlohmann::json& j) {');
+  lines.push('    ' + structName + ' result;');
+  for (const field of fields) {
+    lines.push(`    if (j.contains("${field.name}")) { result.${field.name} = j["${field.name}"]; }`);
+  }
+  lines.push('    return result;');
+  lines.push('  }');
+  
+  // Add to_json helper
+  lines.push('');
+  lines.push('  nlohmann::json to_json() const {');
+  lines.push('    nlohmann::json j;');
+  for (const field of fields) {
+    lines.push(`    j["${field.name}"] = ${field.name};`);
+  }
+  lines.push('    return j;');
+  lines.push('  }');
+  
+  lines.push('};');
+  return lines.join('\n');
+}
+
+function generateConnectionCpp(methods) {
+  const lines = [];
+  lines.push('/**');
+  lines.push(' * Auto-generated by plusui-bindgen');
+  lines.push(' * DO NOT EDIT - Changes will be overwritten');
+  lines.push(' * Generated from: connection.schema');
+  lines.push(' */');
+  lines.push('#pragma once');
+  lines.push('#include <plusui/connection.hpp>');
+  lines.push('#include <string>');
+  lines.push('#include <vector>');
+  lines.push('');
+  lines.push('namespace plusui {');
+  lines.push('namespace connect {');
+  lines.push('');
+  
+  lines.push('// ============================================');
+  lines.push('// Type Definitions');
+  lines.push('// ============================================');
+  lines.push('');
+
+  // Generate structs for all methods
+  for (const method of methods) {
+    const base = toPascalCase(method.name);
+    
+    // Input struct
+    if (method.params.length > 0) {
+      lines.push(emitCppStruct(`${base}In`, method.params));
+      lines.push('');
+    }
+    
+    // Output struct for calls
+    if (method.kind === 'call' && method.result.length > 0) {
+      lines.push(emitCppStruct(`${base}Out`, method.result));
+      lines.push('');
+    }
+    
+    // Data struct for events/streams/channels
+    if (['event', 'stream', 'channel'].includes(method.kind) && method.params.length > 0) {
+      lines.push(emitCppStruct(`${base}Data`, method.params));
+      lines.push('');
+    }
+  }
+
+  lines.push('// ============================================');
+  lines.push('// Generated Bindings Base Class');
+  lines.push('// ============================================');
+  lines.push('');
+  lines.push('/**');
+  lines.push(' * Auto-generated connection bindings');
+  lines.push(' * Inherit from this class and implement the handler methods');
+  lines.push(' */');
+  lines.push('class Bindings : public Connection {');
+  lines.push('public:');
+  lines.push('');
+  
+  lines.push('  // ========================================');
+  lines.push('  // Handler Methods (implement these)');
+  lines.push('  // ========================================');
+  lines.push('');
+
+  // Generate virtual handler methods
+  for (const method of methods) {
+    const base = toPascalCase(method.name);
+    
+    if (method.kind === 'call') {
+      const hasParams = method.params.length > 0;
+      const hasResult = method.result.length > 0;
+      const paramType = hasParams ? `const ${base}In&` : '';
+      const returnType = hasResult ? `${base}Out` : 'void';
+      
+      lines.push(`  /** [CALL] ${method.name} - Request/response handler */`);
+      if (hasParams) {
+        lines.push(`  virtual ${returnType} handle_${method.name}(${paramType} args) = 0;`);
+      } else {
+        lines.push(`  virtual ${returnType} handle_${method.name}() = 0;`);
+      }
+      lines.push('');
+    }
+    
+    if (method.kind === 'fire') {
+      const hasParams = method.params.length > 0;
+      const paramType = hasParams ? `const ${base}In&` : '';
+      
+      lines.push(`  /** [FIRE] ${method.name} - One-way handler */`);
+      if (hasParams) {
+        lines.push(`  virtual void handle_${method.name}(${paramType} args) = 0;`);
+      } else {
+        lines.push(`  virtual void handle_${method.name}() = 0;`);
+      }
+      lines.push('');
+    }
+    
+    if (method.kind === 'channel') {
+      const hasParams = method.params.length > 0;
+      const paramType = hasParams ? `const ${base}Data&` : '';
+      
+      lines.push(`  /** [CHANNEL] ${method.name} - Publish handler */`);
+      if (hasParams) {
+        lines.push(`  virtual void handle_${method.name}_publish(${paramType} data) = 0;`);
+      } else {
+        lines.push(`  virtual void handle_${method.name}_publish() = 0;`);
+      }
+      lines.push('');
     }
+  }
 
-    // Generate custom bindings
-    for (const bindingSource of customBindings) {
-        const generated = generateCustomTsClass(bindingSource);
-        lines.push(generated.code);
-        bindingEntries.push(`  ${generated.instanceName}: new ${generated.className}(),`);
-        bindingExports.push(generated.instanceName);
+  lines.push('  // ========================================');
+  lines.push('  // Emit Methods (call these to send to frontend)');
+  lines.push('  // ========================================');
+  lines.push('');
+
+  // Generate emit methods for events/streams/channels
+  for (const method of methods) {
+    if (!['event', 'stream', 'channel'].includes(method.kind)) {
+      continue;
     }
 
-    // Create unified export
-    lines.push('/**');
-    lines.push(' * Unified PlusUI binding interface');
-    lines.push(' * Access all native and custom bindings through this object');
-    lines.push(' */');
-    lines.push('export const plusui = {');
-    if (bindingEntries.length === 0) {
-        lines.push('  // No bindings discovered yet');
-        lines.push('  // Add PLUSUI_BIND annotations to your C++ code and run: plusui generate');
+    const base = toPascalCase(method.name);
+    const hasParams = method.params.length > 0;
+    const paramType = hasParams ? `const ${base}Data&` : '';
+    
+    let kindLabel = method.kind.toUpperCase();
+    lines.push(`  /** [${kindLabel}] ${method.name} - Emit to frontend */`);
+    
+    if (hasParams) {
+      lines.push(`  void emit_${method.name}(${paramType} data) {`);
+      lines.push(`    auto payload = data.to_json();`);
     } else {
-        for (const entry of bindingEntries) {
-            lines.push(entry);
-        }
+      lines.push(`  void emit_${method.name}() {`);
+      lines.push('    auto payload = nlohmann::json::object();');
     }
-    lines.push('};');
-    lines.push('');
 
-    // Also export individually for flexibility
-    if (bindingExports.length > 0) {
-        lines.push('// Individual exports (alternative import style)');
-        for (const exportName of bindingExports) {
-            lines.push(`export const ${exportName} = plusui.${exportName};`);
-        }
-        lines.push('');
+    if (method.kind === 'event') {
+      lines.push(`    emit("${method.name}", payload);`);
+    } else if (method.kind === 'stream') {
+      lines.push(`    emit("${method.name}", payload);`);
+    } else if (method.kind === 'channel') {
+      lines.push(`    emit("${method.name}", payload);`);
     }
 
-    lines.push('export default plusui;');
+    lines.push('  }');
     lines.push('');
-
-    return lines.join('\n');
+  }
+
+  lines.push('protected:');
+  lines.push('  // ========================================');
+  lines.push('  // Message Dispatcher (auto-generated)');
+  lines.push('  // ========================================');
+  lines.push('');
+  lines.push('  void handleMessage(const std::string &name, const nlohmann::json &payload) override {');
+  lines.push('    try {');
+
+  // Generate CALL handlers (now just emit response)
+  const callMethods = methods.filter((m) => m.kind === 'call');
+  if (callMethods.length > 0) {
+    lines.push('      // CALL handlers (request/response pattern)');
+    for (const method of callMethods) {
+      const base = toPascalCase(method.name);
+      const hasParams = method.params.length > 0;
+      const hasResult = method.result.length > 0;
+      
+      lines.push(`      if (name == "${method.name}") {`);
+      if (hasParams && hasResult) {
+        lines.push(`        auto args = ${base}In::from_json(payload);`);
+        lines.push(`        auto res = handle_${method.name}(args);`);
+        lines.push(`        emit("${method.name}Result", res.to_json());`);
+      } else if (hasParams) {
+        lines.push(`        auto args = ${base}In::from_json(payload);`);
+        lines.push(`        handle_${method.name}(args);`);
+        lines.push(`        emit("${method.name}Result", nlohmann::json::object());`);
+      } else if (hasResult) {
+        lines.push(`        auto res = handle_${method.name}();`);
+        lines.push(`        emit("${method.name}Result", res.to_json());`);
+      } else {
+        lines.push(`        handle_${method.name}();`);
+        lines.push(`        emit("${method.name}Result", nlohmann::json::object());`);
+      }
+      lines.push('        return;');
+      lines.push('      }');
+    }
+    lines.push('');
+  }
+
+  // Generate FIRE handlers (fire & forget)
+  const fireMethods = methods.filter((m) => m.kind === 'fire');
+  if (fireMethods.length > 0) {
+    lines.push('      // FIRE handlers (fire & forget pattern)');
+    for (const method of fireMethods) {
+      const base = toPascalCase(method.name);
+      const hasParams = method.params.length > 0;
+      
+      lines.push(`      if (name == "${method.name}") {`);
+      if (hasParams) {
+        lines.push(`        auto args = ${base}In::from_json(payload);`);
+        lines.push(`        handle_${method.name}(args);`);
+      } else {
+        lines.push(`        handle_${method.name}();`);
+      }
+      lines.push('        return;');
+      lines.push('      }');
+    }
+    lines.push('');
+  }
+
+  // Generate CHANNEL handlers
+  const channelMethods = methods.filter((m) => m.kind === 'channel');
+  if (channelMethods.length > 0) {
+    lines.push('      // CHANNEL publish handlers');
+    for (const method of channelMethods) {
+      const base = toPascalCase(method.name);
+      const hasParams = method.params.length > 0;
+      
+      lines.push(`      if (name == "${method.name}") {`);
+      if (hasParams) {
+        lines.push(`        auto data = ${base}Data::from_json(payload);`);
+        lines.push(`        handle_${method.name}_publish(data);`);
+      } else {
+        lines.push(`        handle_${method.name}_publish();`);
+      }
+      lines.push('        return;');
+      lines.push('      }');
+    }
+  }
+
+  lines.push('    } catch (const std::exception& e) {');
+  lines.push('      // Error handling - log or ignore');
+  lines.push('    }');
+  lines.push('  }');
+  lines.push('};');
+  lines.push('');
+  lines.push('} // namespace connect');
+  lines.push('} // namespace plusui');
+  lines.push('');
+
+  return lines.join('\n');
 }
 
-function generateCustomCppTemplate(customBindings) {
-        const lines = [];
-        lines.push('// Auto-generated by plusui-bindgen');
-        lines.push('// Custom backend binding template');
-        lines.push('');
-        lines.push('#include "custom.bindings.gen.hpp"');
-        lines.push('');
-
-        for (const bindingSource of customBindings) {
-            lines.push(`// Source: ${bindingSource.name}`);
-            for (const operation of bindingSource.operations) {
-                lines.push(`// TODO: Implement ${operation.kind} binding for ${bindingSource.name}.${operation.name}`);
-                }
-            for (const eventItem of bindingSource.events) {
-                lines.push(`// TODO: Implement event binding for ${bindingSource.name}.${eventItem.name}`);
-                }
-                lines.push('');
-        }
-
-        if (customBindings.length === 0) {
-            lines.push('// No custom backend bindings discovered yet.');
-        }
-
-        return lines.join('\n');
-}
+async function writeOutputs(projectRoot, methods, schemaKind) {
+  const tsOutDir = resolve(projectRoot, 'Core/Features/Connection/generated');
+  const cppOutDir = tsOutDir;
 
-function generateNativeCppTemplate(coreFeatureMethods) {
-    const lines = [];
-    lines.push('// Auto-generated by plusui-bindgen');
-    lines.push('// Native backend binding template');
-    lines.push('');
-    lines.push('#include "core.bindings.gen.hpp"');
-    lines.push('');
+  await mkdir(tsOutDir, { recursive: true });
+  await mkdir(cppOutDir, { recursive: true });
 
-    if (coreFeatureMethods.size === 0) {
-        lines.push('// No native core bindings detected for this app yet.');
-        return lines.join('\n');
-    }
+  const tsContent = generateConnectionTs(methods);
+  const cppContent = generateConnectionCpp(methods);
 
-    for (const [featureName, methods] of coreFeatureMethods.entries()) {
-        lines.push(`// Native feature: ${featureName}`);
-        for (const methodName of methods) {
-            lines.push(`// TODO: wire native binding for ${featureName}.${methodName}`);
-        }
-        lines.push('');
-    }
+  const tsPath = join(tsOutDir, 'bindings.ts');
+  const cppPath = join(cppOutDir, 'bindings.hpp');
 
-    return lines.join('\n');
-}
+  await writeFile(tsPath, tsContent);
+  await writeFile(cppPath, cppContent);
 
-function generateFrontendHtmlSummary(coreFeatureMethods, customBindings) {
-        const coreRows = Array.from(coreFeatureMethods.entries())
-                .map(([feature, methods]) => `<tr><td>${feature}</td><td>native</td><td>${methods.join(', ') || '-'}</td></tr>`)
-                .join('');
-
-        const customRows = customBindings
-            .map(bindingSource => `<tr><td>${bindingSource.name}</td><td>custom</td><td>${bindingSource.operations.map(m => `${m.name} [${m.kind}]`).join(', ') || '-'}</td></tr>`)
-                .join('');
-
-        return `<!doctype html>
-<html>
-<head>
-    <meta charset="utf-8" />
-    <title>PlusUI Bindings Summary</title>
-</head>
-<body>
-    <h1>PlusUI Bindings Summary</h1>
-    <p>Generated by plusui bindgen</p>
-    <table border="1" cellspacing="0" cellpadding="6">
-        <thead>
-            <tr>
-                <th>Feature</th>
-                <th>Type</th>
-                <th>Methods</th>
-            </tr>
-        </thead>
-        <tbody>
-            ${coreRows}${customRows}
-        </tbody>
-    </table>
-</body>
-</html>
-`;
-}
+  const legacyTsOut = resolve(projectRoot, 'src/generated');
+  const legacyCppOut = resolve(projectRoot, 'Core/generated');
+  await mkdir(legacyTsOut, { recursive: true });
+  await mkdir(legacyCppOut, { recursive: true });
+  await writeFile(join(legacyTsOut, 'bridge.ts'), tsContent);
+  await writeFile(join(legacyCppOut, 'bridge.hpp'), cppContent);
 
-async function generateBindings(projectRoot, outputDir) {
-    const root = resolve(projectRoot);
-    const coreFeaturesDir = findCoreFeaturesDir(root);
-    const includeOutputDir = join(root, 'include', 'Bindings');
-
-    const usedCoreFeatures = await detectUsedCoreFeatures(root);
-    const coreFeatureMethods = await parseCoreFeatureMethods(coreFeaturesDir, usedCoreFeatures);
-    const customBindings = await parseCustomBackendBindings(root);
-
-    await mkdir(outputDir, { recursive: true });
-
-    const nativeBackendDir = join(outputDir, 'NativeBindings', 'CPP_IO');
-    const nativeFrontendDir = join(outputDir, 'NativeBindings', 'WEB_IO');
-    const customBackendDir = join(outputDir, 'CustomBindings', 'CPP_IO');
-    const customFrontendDir = join(outputDir, 'CustomBindings', 'WEB_IO');
-    const includeNativeBackendDir = join(includeOutputDir, 'NativeBindings', 'CPP_IO');
-    const includeCustomBackendDir = join(includeOutputDir, 'CustomBindings', 'CPP_IO');
-
-    await mkdir(nativeBackendDir, { recursive: true });
-    await mkdir(nativeFrontendDir, { recursive: true });
-    await mkdir(customBackendDir, { recursive: true });
-    await mkdir(customFrontendDir, { recursive: true });
-    await mkdir(includeNativeBackendDir, { recursive: true });
-    await mkdir(includeCustomBackendDir, { recursive: true });
-
-    const cppOut = join(outputDir, 'bindings.gen.hpp');
-    const tsOut = join(outputDir, 'bindings.gen.ts');
-    const reportOut = join(outputDir, 'bindings.report.json');
-    const nativeCppOut = join(nativeBackendDir, 'core.bindings.gen.hpp');
-    const nativeCppTemplateOut = join(nativeBackendDir, 'core.bindings.gen.cpp');
-    const nativeTsOut = join(nativeFrontendDir, 'core.bindings.gen.ts');
-    const customCppOut = join(customBackendDir, 'custom.bindings.gen.hpp');
-    const customCppTemplateOut = join(customBackendDir, 'custom.bindings.gen.cpp');
-    const customTsOut = join(customFrontendDir, 'custom.bindings.gen.ts');
-    const customHtmlOut = join(customFrontendDir, 'custom.bindings.gen.html');
-    const includeCppOut = join(includeOutputDir, 'bindings.gen.hpp');
-    const includeNativeCppOut = join(includeNativeBackendDir, 'core.bindings.gen.hpp');
-    const includeCustomCppOut = join(includeCustomBackendDir, 'custom.bindings.gen.hpp');
-
-    const allCppBindings = generateCppBindings(customBindings, coreFeatureMethods);
-    const nativeCppBindings = generateCppBindings([], coreFeatureMethods);
-    const customCppBindings = generateCppBindings(customBindings, new Map());
-
-    await writeFile(cppOut, allCppBindings);
-    await writeFile(tsOut, generateTsBindings(coreFeatureMethods, customBindings));
-    await writeFile(nativeCppOut, nativeCppBindings);
-    await writeFile(nativeCppTemplateOut, generateNativeCppTemplate(coreFeatureMethods));
-    await writeFile(nativeTsOut, generateTsBindings(coreFeatureMethods, []));
-    await writeFile(customCppOut, customCppBindings);
-    await writeFile(customCppTemplateOut, generateCustomCppTemplate(customBindings));
-    await writeFile(customTsOut, generateTsBindings(new Map(), customBindings));
-    await writeFile(customHtmlOut, generateFrontendHtmlSummary(coreFeatureMethods, customBindings));
-    await writeFile(includeCppOut, allCppBindings);
-    await writeFile(includeNativeCppOut, nativeCppBindings);
-    await writeFile(includeCustomCppOut, customCppBindings);
-
-    const report = {
-        projectRoot: root,
-        outputDir: resolve(outputDir),
-        extensionBuckets: {
-            WEB_IO: Array.from(WEB_IO),
-            CPP_IO: Array.from(CPP_IO),
-        },
-        coreFeaturesDir,
-        usedCoreFeatures: Array.from(usedCoreFeatures).sort((a, b) => a.localeCompare(b)),
-        generatedCoreFeatures: Array.from(coreFeatureMethods.entries()).map(([name, methods]) => ({ name, methods })),
-        customBindings: customBindings.map(bindingSource => ({
-            name: bindingSource.name,
-            sourcePath: relative(root, bindingSource.sourcePath),
-            operations: bindingSource.operations.map(m => ({ name: m.name, kind: m.kind })),
-            events: bindingSource.events.map(e => e.name),
-        })),
-        generatedFiles: [
-            relative(root, cppOut),
-            relative(root, tsOut),
-            relative(root, nativeCppOut),
-            relative(root, nativeCppTemplateOut),
-            relative(root, nativeTsOut),
-            relative(root, customCppOut),
-            relative(root, customCppTemplateOut),
-            relative(root, customTsOut),
-            relative(root, customHtmlOut),
-            relative(root, includeCppOut),
-            relative(root, includeNativeCppOut),
-            relative(root, includeCustomCppOut),
-            relative(root, reportOut),
-        ],
-    };
-
-    await writeFile(reportOut, JSON.stringify(report, null, 2));
-
-    const coreMethodCount = Array.from(coreFeatureMethods.values()).reduce((sum, list) => sum + list.length, 0);
-    const customBindingCount = customBindings.reduce((sum, bindingSource) => sum + bindingSource.operations.length + bindingSource.events.length, 0);
-
-    console.log('\n🔧 PlusUI Bindgen\n');
-    console.log(`Project: ${root}`);
-    console.log(`Output:  ${resolve(outputDir)}\n`);
-    console.log(`Core features used: ${coreFeatureMethods.size}`);
-    console.log(`Core methods generated: ${coreMethodCount}`);
-    console.log(`Custom binding sources discovered: ${customBindings.length}`);
-    console.log(`Custom bindings generated: ${customBindingCount}`);
-    console.log('');
-    console.log(`Generated: ${relative(root, cppOut)}`);
-    console.log(`Generated: ${relative(root, tsOut)}`);
-    console.log(`Generated: ${relative(root, nativeCppOut)}`);
-    console.log(`Generated: ${relative(root, nativeCppTemplateOut)}`);
-    console.log(`Generated: ${relative(root, nativeTsOut)}`);
-    console.log(`Generated: ${relative(root, customCppOut)}`);
-    console.log(`Generated: ${relative(root, customCppTemplateOut)}`);
-    console.log(`Generated: ${relative(root, customTsOut)}`);
-    console.log(`Generated: ${relative(root, customHtmlOut)}`);
-    console.log(`Generated: ${relative(root, includeCppOut)}`);
-    console.log(`Generated: ${relative(root, includeNativeCppOut)}`);
-    console.log(`Generated: ${relative(root, includeCustomCppOut)}`);
-    console.log(`Generated: ${relative(root, reportOut)}`);
-    console.log('\n✨ Bindings generated successfully!\n');
+  console.log(`📖 Schema mode: ${schemaKind}`);
+  console.log(`Generated TS bindings: ${tsPath}`);
+  console.log(`Generated C++ bindings: ${cppPath}`);
+  console.log(`Synced legacy outputs: ${join(legacyTsOut, 'bridge.ts')} / ${join(legacyCppOut, 'bridge.hpp')}`);
 }
 
 async function main() {
-    const args = process.argv.slice(2);
-    const projectRoot = args[0] || '.';
-    const outputDir = args[1] || './src/Bindings';
-
-    const rootStats = await stat(projectRoot).catch(() => null);
-    if (!rootStats || !rootStats.isDirectory()) {
-        console.log(`⚠️  Project root is missing or not a directory: ${projectRoot}`);
-        process.exit(1);
-    }
+  const args = process.argv.slice(2);
+  const projectRoot = args[0] || process.cwd();
+
+  const { methods, schemaPath, schemaKind } = await loadSchema(projectRoot);
+  console.log(`Using schema: ${schemaPath}`);
+
+  const normalizedMethods = methods.map((method) => ({
+    ...method,
+    kind: LEGACY_KIND_MAP[method.kind] || method.kind,
+  }));
 
-    await generateBindings(projectRoot, outputDir);
+  await writeOutputs(projectRoot, normalizedMethods, schemaKind);
+  console.log('✅ Bindings generation complete!');
 }
 
-main().catch(error => {
-    console.error('❌ Error:', error.message);
-    process.exit(1);
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
 });