@nice2dev/game-engine 1.3.14 → 1.3.16

package/dist/esm/godot-integration/GodotAssetLibrary.js

@@ -1,710 +1,682 @@
-/**
- * @file GodotAssetLibrary.ts
- * @description Godot Asset Library Integration for Nice2Dev Game Engine
- * PRO-1.9.3: Godot Asset Library Integration
- *
- * Features:
- * - Asset Library browser
- * - Asset search and filtering
- * - One-click install
- * - Version compatibility check
- * - GDExtension support
- */
-// ============================================================
-// Asset Library Browser
-// ============================================================
 class GodotAssetLibraryBrowser {
-    constructor(config) {
-        this.cache = new Map();
-        this.callbacks = {};
-        this.config = {
-            apiBaseUrl: 'https://godotengine.org/asset-library/api',
-            cacheDuration: 300000, // 5 minutes
-            defaultGodotVersion: '4.3',
-            defaultPageSize: 40,
-            ...config,
-        };
-    }
-    // ─── Search & Browse ───────────────────────────────────
-    async search(query) {
-        const cacheKey = `search:${JSON.stringify(query)}`;
-        const cached = this.getFromCache(cacheKey);
-        if (cached) {
-            return cached;
-        }
-        // Build query string
-        const params = new URLSearchParams();
-        if (query.type && query.type !== 'any') {
-            params.append('type', query.type);
-        }
-        if (query.category) {
-            params.append('category', query.category);
-        }
-        if (query.filter) {
-            params.append('filter', query.filter);
-        }
-        if (query.user) {
-            params.append('user', query.user);
-        }
-        if (query.godot_version) {
-            params.append('godot_version', query.godot_version);
-        }
-        if (query.max_results) {
-            params.append('max_results', String(query.max_results));
-        }
-        if (query.page) {
-            params.append('page', String(query.page));
-        }
-        if (query.sort) {
-            params.append('sort', query.sort);
-        }
-        if (query.reverse) {
-            params.append('reverse', 'true');
-        }
-        // In real implementation, fetch from API
-        const result = await this.mockSearch(query);
-        this.setCache(cacheKey, result);
-        this.callbacks.onSearchComplete?.(result);
-        return result;
-    }
-    async getAsset(assetId) {
-        const cacheKey = `asset:${assetId}`;
-        const cached = this.getFromCache(cacheKey);
-        if (cached) {
-            return cached;
-        }
-        // In real implementation, fetch from API
-        const asset = await this.mockGetAsset(assetId);
-        if (asset) {
-            this.setCache(cacheKey, asset);
-        }
-        return asset;
-    }
-    async getCategories() {
-        return [
-            { id: '2d_tools', name: '2D Tools' },
-            { id: '3d_tools', name: '3D Tools' },
-            { id: 'shaders', name: 'Shaders' },
-            { id: 'materials', name: 'Materials' },
-            { id: 'tools', name: 'Tools' },
-            { id: 'scripts', name: 'Scripts' },
-            { id: 'misc', name: 'Misc' },
-            { id: 'templates', name: 'Templates' },
-            { id: 'projects', name: 'Projects' },
-            { id: 'demos', name: 'Demos' },
-            { id: 'addons', name: 'Add-ons' },
-        ];
-    }
-    async getPopularAddons(count = 10) {
-        const result = await this.search({
-            type: 'addon',
-            sort: 'rating',
-            order: 'desc',
-            max_results: count,
-        });
-        return result.result;
-    }
-    async getRecentlyUpdated(count = 10) {
-        const result = await this.search({
-            sort: 'updated',
-            order: 'desc',
-            max_results: count,
-        });
-        return result.result;
-    }
-    async getOfficialAssets() {
-        const result = await this.search({
-            support: ['official'],
-            sort: 'rating',
-            order: 'desc',
-        });
-        return result.result;
-    }
-    // ─── Download & Install ────────────────────────────────
-    async initiateDownload(assetId) {
-        const asset = await this.getAsset(assetId);
-        if (!asset) {
-            throw new Error('Asset not found');
-        }
-        const downloadInfo = {
-            assetId,
-            downloadUrl: asset.download_url,
-            fileName: `${asset.title.replace(/\s+/g, '_')}_v${asset.version_string}.zip`,
-            hash: asset.download_hash,
-        };
-        this.callbacks.onDownloadStart?.(downloadInfo);
-        return downloadInfo;
-    }
-    async installAddon(assetId, projectPath) {
-        await this.initiateDownload(assetId);
-        // In real implementation:
-        // 1. Download the zip file
-        // 2. Extract to addons/ folder
-        // 3. Verify contents
-        const result = {
-            success: true,
-            assetId,
-            installedPath: `${projectPath}/addons/${assetId}`,
-            files: [],
-        };
-        this.callbacks.onInstallComplete?.(result);
-        return result;
-    }
-    checkCompatibility(asset, targetVersion) {
-        const assetMajor = parseInt(asset.godot_version.split('.')[0], 10);
-        const assetMinor = parseInt(asset.godot_version.split('.')[1], 10);
-        const targetMajor = parseInt(targetVersion.split('.')[0], 10);
-        const targetMinor = parseInt(targetVersion.split('.')[1], 10);
-        if (assetMajor !== targetMajor) {
-            return {
-                isCompatible: false,
-                reason: `Asset requires Godot ${assetMajor}.x, but target is ${targetMajor}.x`,
-                severity: 'error',
-            };
-        }
-        if (assetMinor > targetMinor) {
-            return {
-                isCompatible: false,
-                reason: `Asset requires Godot ${asset.godot_version} or higher`,
-                severity: 'warning',
-            };
-        }
-        return {
-            isCompatible: true,
-        };
-    }
-    // ─── Caching ───────────────────────────────────────────
-    getFromCache(key) {
-        const cached = this.cache.get(key);
-        if (!cached) {
-            return null;
-        }
-        if (Date.now() - cached.timestamp > this.config.cacheDuration) {
-            this.cache.delete(key);
-            return null;
-        }
-        return cached.data;
-    }
-    setCache(key, data) {
-        this.cache.set(key, { data, timestamp: Date.now() });
-    }
-    clearCache() {
-        this.cache.clear();
-    }
-    // ─── Mock Data ─────────────────────────────────────────
-    async mockSearch(query) {
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        const mockAssets = [
-            {
-                asset_id: '1',
-                type: 'addon',
-                title: 'GDQuest Dialogic',
-                author: 'gdquest',
-                author_id: '100',
-                category: 'tools',
-                category_id: '5',
-                cost: '0',
-                description: 'Create dialogs, branching conversations, and cutscenes with a powerful, non-linear node-based editor.',
-                support_level: 'community',
-                godot_version: '4.2',
-                version_string: '2.0.0',
-                version: 200,
-                rating: 4.8,
-                download_url: 'https://example.com/dialogic.zip',
-                download_hash: 'sha256:...',
-                browse_url: 'https://godotengine.org/asset-library/asset/1',
-                icon_url: 'https://example.com/dialogic-icon.png',
-                previews: [],
-                modify_date: '2024-01-15T00:00:00Z',
-                tags: ['dialog', 'visual-novel', 'branching'],
-            },
-            {
-                asset_id: '2',
-                type: 'addon',
-                title: 'Phantom Camera',
-                author: 'ramokz',
-                author_id: '200',
-                category: '3d_tools',
-                category_id: '2',
-                cost: '0',
-                description: 'A dynamic 2D & 3D camera addon for Godot 4.',
-                support_level: 'community',
-                godot_version: '4.2',
-                version_string: '0.6.0',
-                version: 60,
-                rating: 4.9,
-                download_url: 'https://example.com/phantom-camera.zip',
-                download_hash: 'sha256:...',
-                browse_url: 'https://godotengine.org/asset-library/asset/2',
-                icon_url: 'https://example.com/phantom-camera-icon.png',
-                previews: [],
-                modify_date: '2024-02-01T00:00:00Z',
-                tags: ['camera', '2d', '3d', 'cinematic'],
-            },
-            {
-                asset_id: '3',
-                type: 'addon',
-                title: 'GodotSteam',
-                author: 'gramps',
-                author_id: '300',
-                category: 'scripts',
-                category_id: '6',
-                cost: '0',
-                description: 'An ecosystem of tools for Steam integration in the Godot game engine.',
-                support_level: 'community',
-                godot_version: '4.2',
-                version_string: '4.6.0',
-                version: 460,
-                rating: 4.7,
-                download_url: 'https://example.com/godotsteam.zip',
-                download_hash: 'sha256:...',
-                browse_url: 'https://godotengine.org/asset-library/asset/3',
-                icon_url: 'https://example.com/godotsteam-icon.png',
-                previews: [],
-                modify_date: '2024-01-20T00:00:00Z',
-                tags: ['steam', 'networking', 'achievements'],
-            },
-            {
-                asset_id: '4',
-                type: 'addon',
-                title: 'Terrain3D',
-                author: 'outobugi',
-                author_id: '400',
-                category: '3d_tools',
-                category_id: '2',
-                cost: '0',
-                description: 'An editable terrain system for Godot 4, written in C++/GDExtension.',
-                support_level: 'community',
-                godot_version: '4.2',
-                version_string: '0.9.0',
-                version: 90,
-                rating: 4.8,
-                download_url: 'https://example.com/terrain3d.zip',
-                download_hash: 'sha256:...',
-                browse_url: 'https://godotengine.org/asset-library/asset/4',
-                icon_url: 'https://example.com/terrain3d-icon.png',
-                previews: [],
-                modify_date: '2024-01-25T00:00:00Z',
-                tags: ['terrain', '3d', 'gdextension', 'editor'],
-            },
-            {
-                asset_id: '5',
-                type: 'addon',
-                title: 'Godot Jolt',
-                author: 'godot-jolt',
-                author_id: '500',
-                category: 'scripts',
-                category_id: '6',
-                cost: '0',
-                description: 'Godot Jolt is a native extension that allows you to use the Jolt physics engine in Godot.',
-                support_level: 'community',
-                godot_version: '4.2',
-                version_string: '0.11.0',
-                version: 110,
-                rating: 4.9,
-                download_url: 'https://example.com/godot-jolt.zip',
-                download_hash: 'sha256:...',
-                browse_url: 'https://godotengine.org/asset-library/asset/5',
-                icon_url: 'https://example.com/godot-jolt-icon.png',
-                previews: [],
-                modify_date: '2024-02-05T00:00:00Z',
-                tags: ['physics', 'jolt', 'gdextension', '3d'],
-            },
-        ];
-        let filtered = [...mockAssets];
-        // Apply filters
-        if (query.filter) {
-            const filterLower = query.filter.toLowerCase();
-            filtered = filtered.filter((a) => a.title.toLowerCase().includes(filterLower) ||
-                a.description.toLowerCase().includes(filterLower) ||
-                a.tags?.some((t) => t.toLowerCase().includes(filterLower)));
-        }
-        if (query.category) {
-            filtered = filtered.filter((a) => a.category === query.category);
-        }
-        if (query.type && query.type !== 'any') {
-            filtered = filtered.filter((a) => a.type === query.type);
-        }
-        if (query.godot_version) {
-            filtered = filtered.filter((a) => {
-                const assetMajor = parseInt(a.godot_version.split('.')[0], 10);
-                const targetMajor = parseInt(query.godot_version.split('.')[0], 10);
-                return assetMajor === targetMajor;
-            });
-        }
-        if (query.support) {
-            filtered = filtered.filter((a) => query.support.includes(a.support_level));
-        }
-        if (query.user) {
-            filtered = filtered.filter((a) => a.author.toLowerCase() === query.user.toLowerCase());
-        }
-        // Sort
-        switch (query.sort) {
-            case 'rating':
-                filtered.sort((a, b) => b.rating - a.rating);
-                break;
-            case 'name':
-                filtered.sort((a, b) => a.title.localeCompare(b.title));
-                break;
-            case 'updated':
-                filtered.sort((a, b) => new Date(b.modify_date).getTime() - new Date(a.modify_date).getTime());
-                break;
-        }
-        if (query.reverse || query.order === 'asc') {
-            filtered.reverse();
-        }
-        const page = query.page ?? 0;
-        const pageSize = query.max_results ?? this.config.defaultPageSize;
-        const start = page * pageSize;
-        const paged = filtered.slice(start, start + pageSize);
-        return {
-            result: paged,
-            page,
-            page_length: paged.length,
-            pages: Math.ceil(filtered.length / pageSize),
-            total_items: filtered.length,
-        };
-    }
-    async mockGetAsset(assetId) {
-        const result = await this.mockSearch({});
-        return result.result.find((a) => a.asset_id === assetId) ?? null;
-    }
-    // ─── Callbacks ─────────────────────────────────────────
-    setCallbacks(callbacks) {
-        this.callbacks = { ...this.callbacks, ...callbacks };
+  constructor(config) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.callbacks = {};
+    this.config = {
+      apiBaseUrl: "https://godotengine.org/asset-library/api",
+      cacheDuration: 3e5,
+      // 5 minutes
+      defaultGodotVersion: "4.3",
+      defaultPageSize: 40,
+      ...config
+    };
+  }
+  // ─── Search & Browse ───────────────────────────────────
+  async search(query) {
+    const cacheKey = `search:${JSON.stringify(query)}`;
+    const cached = this.getFromCache(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const params = new URLSearchParams();
+    if (query.type && query.type !== "any") {
+      params.append("type", query.type);
+    }
+    if (query.category) {
+      params.append("category", query.category);
+    }
+    if (query.filter) {
+      params.append("filter", query.filter);
+    }
+    if (query.user) {
+      params.append("user", query.user);
+    }
+    if (query.godot_version) {
+      params.append("godot_version", query.godot_version);
+    }
+    if (query.max_results) {
+      params.append("max_results", String(query.max_results));
+    }
+    if (query.page) {
+      params.append("page", String(query.page));
+    }
+    if (query.sort) {
+      params.append("sort", query.sort);
+    }
+    if (query.reverse) {
+      params.append("reverse", "true");
+    }
+    const result = await this.mockSearch(query);
+    this.setCache(cacheKey, result);
+    this.callbacks.onSearchComplete?.(result);
+    return result;
+  }
+  async getAsset(assetId) {
+    const cacheKey = `asset:${assetId}`;
+    const cached = this.getFromCache(cacheKey);
+    if (cached) {
+      return cached;
     }
+    const asset = await this.mockGetAsset(assetId);
+    if (asset) {
+      this.setCache(cacheKey, asset);
+    }
+    return asset;
+  }
+  async getCategories() {
+    return [
+      { id: "2d_tools", name: "2D Tools" },
+      { id: "3d_tools", name: "3D Tools" },
+      { id: "shaders", name: "Shaders" },
+      { id: "materials", name: "Materials" },
+      { id: "tools", name: "Tools" },
+      { id: "scripts", name: "Scripts" },
+      { id: "misc", name: "Misc" },
+      { id: "templates", name: "Templates" },
+      { id: "projects", name: "Projects" },
+      { id: "demos", name: "Demos" },
+      { id: "addons", name: "Add-ons" }
+    ];
+  }
+  async getPopularAddons(count = 10) {
+    const result = await this.search({
+      type: "addon",
+      sort: "rating",
+      order: "desc",
+      max_results: count
+    });
+    return result.result;
+  }
+  async getRecentlyUpdated(count = 10) {
+    const result = await this.search({
+      sort: "updated",
+      order: "desc",
+      max_results: count
+    });
+    return result.result;
+  }
+  async getOfficialAssets() {
+    const result = await this.search({
+      support: ["official"],
+      sort: "rating",
+      order: "desc"
+    });
+    return result.result;
+  }
+  // ─── Download & Install ────────────────────────────────
+  async initiateDownload(assetId) {
+    const asset = await this.getAsset(assetId);
+    if (!asset) {
+      throw new Error("Asset not found");
+    }
+    const downloadInfo = {
+      assetId,
+      downloadUrl: asset.download_url,
+      fileName: `${asset.title.replace(/\s+/g, "_")}_v${asset.version_string}.zip`,
+      hash: asset.download_hash
+    };
+    this.callbacks.onDownloadStart?.(downloadInfo);
+    return downloadInfo;
+  }
+  async installAddon(assetId, projectPath) {
+    await this.initiateDownload(assetId);
+    const result = {
+      success: true,
+      assetId,
+      installedPath: `${projectPath}/addons/${assetId}`,
+      files: []
+    };
+    this.callbacks.onInstallComplete?.(result);
+    return result;
+  }
+  checkCompatibility(asset, targetVersion) {
+    const assetMajor = parseInt(asset.godot_version.split(".")[0], 10);
+    const assetMinor = parseInt(asset.godot_version.split(".")[1], 10);
+    const targetMajor = parseInt(targetVersion.split(".")[0], 10);
+    const targetMinor = parseInt(targetVersion.split(".")[1], 10);
+    if (assetMajor !== targetMajor) {
+      return {
+        isCompatible: false,
+        reason: `Asset requires Godot ${assetMajor}.x, but target is ${targetMajor}.x`,
+        severity: "error"
+      };
+    }
+    if (assetMinor > targetMinor) {
+      return {
+        isCompatible: false,
+        reason: `Asset requires Godot ${asset.godot_version} or higher`,
+        severity: "warning"
+      };
+    }
+    return {
+      isCompatible: true
+    };
+  }
+  // ─── Caching ───────────────────────────────────────────
+  getFromCache(key) {
+    const cached = this.cache.get(key);
+    if (!cached) {
+      return null;
+    }
+    if (Date.now() - cached.timestamp > this.config.cacheDuration) {
+      this.cache.delete(key);
+      return null;
+    }
+    return cached.data;
+  }
+  setCache(key, data) {
+    this.cache.set(key, { data, timestamp: Date.now() });
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  // ─── Mock Data ─────────────────────────────────────────
+  async mockSearch(query) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const mockAssets = [
+      {
+        asset_id: "1",
+        type: "addon",
+        title: "GDQuest Dialogic",
+        author: "gdquest",
+        author_id: "100",
+        category: "tools",
+        category_id: "5",
+        cost: "0",
+        description: "Create dialogs, branching conversations, and cutscenes with a powerful, non-linear node-based editor.",
+        support_level: "community",
+        godot_version: "4.2",
+        version_string: "2.0.0",
+        version: 200,
+        rating: 4.8,
+        download_url: "https://example.com/dialogic.zip",
+        download_hash: "sha256:...",
+        browse_url: "https://godotengine.org/asset-library/asset/1",
+        icon_url: "https://example.com/dialogic-icon.png",
+        previews: [],
+        modify_date: "2024-01-15T00:00:00Z",
+        tags: ["dialog", "visual-novel", "branching"]
+      },
+      {
+        asset_id: "2",
+        type: "addon",
+        title: "Phantom Camera",
+        author: "ramokz",
+        author_id: "200",
+        category: "3d_tools",
+        category_id: "2",
+        cost: "0",
+        description: "A dynamic 2D & 3D camera addon for Godot 4.",
+        support_level: "community",
+        godot_version: "4.2",
+        version_string: "0.6.0",
+        version: 60,
+        rating: 4.9,
+        download_url: "https://example.com/phantom-camera.zip",
+        download_hash: "sha256:...",
+        browse_url: "https://godotengine.org/asset-library/asset/2",
+        icon_url: "https://example.com/phantom-camera-icon.png",
+        previews: [],
+        modify_date: "2024-02-01T00:00:00Z",
+        tags: ["camera", "2d", "3d", "cinematic"]
+      },
+      {
+        asset_id: "3",
+        type: "addon",
+        title: "GodotSteam",
+        author: "gramps",
+        author_id: "300",
+        category: "scripts",
+        category_id: "6",
+        cost: "0",
+        description: "An ecosystem of tools for Steam integration in the Godot game engine.",
+        support_level: "community",
+        godot_version: "4.2",
+        version_string: "4.6.0",
+        version: 460,
+        rating: 4.7,
+        download_url: "https://example.com/godotsteam.zip",
+        download_hash: "sha256:...",
+        browse_url: "https://godotengine.org/asset-library/asset/3",
+        icon_url: "https://example.com/godotsteam-icon.png",
+        previews: [],
+        modify_date: "2024-01-20T00:00:00Z",
+        tags: ["steam", "networking", "achievements"]
+      },
+      {
+        asset_id: "4",
+        type: "addon",
+        title: "Terrain3D",
+        author: "outobugi",
+        author_id: "400",
+        category: "3d_tools",
+        category_id: "2",
+        cost: "0",
+        description: "An editable terrain system for Godot 4, written in C++/GDExtension.",
+        support_level: "community",
+        godot_version: "4.2",
+        version_string: "0.9.0",
+        version: 90,
+        rating: 4.8,
+        download_url: "https://example.com/terrain3d.zip",
+        download_hash: "sha256:...",
+        browse_url: "https://godotengine.org/asset-library/asset/4",
+        icon_url: "https://example.com/terrain3d-icon.png",
+        previews: [],
+        modify_date: "2024-01-25T00:00:00Z",
+        tags: ["terrain", "3d", "gdextension", "editor"]
+      },
+      {
+        asset_id: "5",
+        type: "addon",
+        title: "Godot Jolt",
+        author: "godot-jolt",
+        author_id: "500",
+        category: "scripts",
+        category_id: "6",
+        cost: "0",
+        description: "Godot Jolt is a native extension that allows you to use the Jolt physics engine in Godot.",
+        support_level: "community",
+        godot_version: "4.2",
+        version_string: "0.11.0",
+        version: 110,
+        rating: 4.9,
+        download_url: "https://example.com/godot-jolt.zip",
+        download_hash: "sha256:...",
+        browse_url: "https://godotengine.org/asset-library/asset/5",
+        icon_url: "https://example.com/godot-jolt-icon.png",
+        previews: [],
+        modify_date: "2024-02-05T00:00:00Z",
+        tags: ["physics", "jolt", "gdextension", "3d"]
+      }
+    ];
+    let filtered = [...mockAssets];
+    if (query.filter) {
+      const filterLower = query.filter.toLowerCase();
+      filtered = filtered.filter(
+        (a) => a.title.toLowerCase().includes(filterLower) || a.description.toLowerCase().includes(filterLower) || a.tags?.some((t) => t.toLowerCase().includes(filterLower))
+      );
+    }
+    if (query.category) {
+      filtered = filtered.filter((a) => a.category === query.category);
+    }
+    if (query.type && query.type !== "any") {
+      filtered = filtered.filter((a) => a.type === query.type);
+    }
+    if (query.godot_version) {
+      filtered = filtered.filter((a) => {
+        const assetMajor = parseInt(a.godot_version.split(".")[0], 10);
+        const targetMajor = parseInt(query.godot_version.split(".")[0], 10);
+        return assetMajor === targetMajor;
+      });
+    }
+    if (query.support) {
+      filtered = filtered.filter((a) => query.support.includes(a.support_level));
+    }
+    if (query.user) {
+      filtered = filtered.filter((a) => a.author.toLowerCase() === query.user.toLowerCase());
+    }
+    switch (query.sort) {
+      case "rating":
+        filtered.sort((a, b) => b.rating - a.rating);
+        break;
+      case "name":
+        filtered.sort((a, b) => a.title.localeCompare(b.title));
+        break;
+      case "updated":
+        filtered.sort(
+          (a, b) => new Date(b.modify_date).getTime() - new Date(a.modify_date).getTime()
+        );
+        break;
+    }
+    if (query.reverse || query.order === "asc") {
+      filtered.reverse();
+    }
+    const page = query.page ?? 0;
+    const pageSize = query.max_results ?? this.config.defaultPageSize;
+    const start = page * pageSize;
+    const paged = filtered.slice(start, start + pageSize);
+    return {
+      result: paged,
+      page,
+      page_length: paged.length,
+      pages: Math.ceil(filtered.length / pageSize),
+      total_items: filtered.length
+    };
+  }
+  async mockGetAsset(assetId) {
+    const result = await this.mockSearch({});
+    return result.result.find((a) => a.asset_id === assetId) ?? null;
+  }
+  // ─── Callbacks ─────────────────────────────────────────
+  setCallbacks(callbacks) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+  }
 }
-// ============================================================
-// GDExtension Manager
-// ============================================================
 class GDExtensionManager {
-    constructor() {
-        this.extensions = new Map();
-        this.bindings = new Map();
-        this.callbacks = {};
-        // Initialize with known GDExtensions
-        this.registerKnownExtensions();
-    }
-    registerKnownExtensions() {
-        // Common GDExtensions in the ecosystem
-        const knownExtensions = [
-            {
-                name: 'godot-jolt',
-                manifestPath: 'addons/godot-jolt/godot-jolt.gdextension',
-                manifest: {
-                    config_version: 1,
-                    name: 'godot-jolt',
-                    entry_symbol: 'godot_jolt_main',
-                    compatibility: { minimum: '4.1' },
-                    libraries: {
-                        'windows.x86_64': 'bin/godot-jolt.windows.x86_64.dll',
-                        'linux.x86_64': 'bin/libgodot-jolt.linux.x86_64.so',
-                        macos: 'bin/libgodot-jolt.macos.universal.dylib',
-                    },
-                },
-                isCompatible: true,
-                platforms: ['windows', 'linux', 'macos'],
-                isInstalled: false,
-                hasNice2DevBinding: true,
-            },
-            {
-                name: 'terrain3d',
-                manifestPath: 'addons/terrain_3d/terrain.gdextension',
-                manifest: {
-                    config_version: 1,
-                    name: 'terrain3d',
-                    entry_symbol: 'terrain3d_library_init',
-                    compatibility: { minimum: '4.1' },
-                    libraries: {
-                        'windows.x86_64': 'bin/libterrain.windows.x86_64.dll',
-                        'linux.x86_64': 'bin/libterrain.linux.x86_64.so',
-                        macos: 'bin/libterrain.macos.universal.dylib',
-                    },
-                },
-                isCompatible: true,
-                platforms: ['windows', 'linux', 'macos'],
-                isInstalled: false,
-                hasNice2DevBinding: false,
-            },
-            {
-                name: 'godotsteam',
-                manifestPath: 'addons/godotsteam/godotsteam.gdextension',
-                manifest: {
-                    config_version: 1,
-                    name: 'godotsteam',
-                    entry_symbol: 'steam_library_init',
-                    compatibility: { minimum: '4.1' },
-                    libraries: {
-                        'windows.x86_64': 'bin/godotsteam.windows.x86_64.dll',
-                        'linux.x86_64': 'bin/libgodotsteam.linux.x86_64.so',
-                        macos: 'bin/libgodotsteam.macos.universal.dylib',
-                    },
-                    dependencies: {
-                        'windows.x86_64': ['steam_api64.dll'],
-                        'linux.x86_64': ['libsteam_api.so'],
-                        macos: ['libsteam_api.dylib'],
-                    },
-                },
-                isCompatible: true,
-                platforms: ['windows', 'linux', 'macos'],
-                isInstalled: false,
-                hasNice2DevBinding: true,
-            },
-        ];
-        for (const ext of knownExtensions) {
-            this.extensions.set(ext.name, ext);
-        }
+  constructor() {
+    this.extensions = /* @__PURE__ */ new Map();
+    this.bindings = /* @__PURE__ */ new Map();
+    this.callbacks = {};
+    this.registerKnownExtensions();
+  }
+  registerKnownExtensions() {
+    const knownExtensions = [
+      {
+        name: "godot-jolt",
+        manifestPath: "addons/godot-jolt/godot-jolt.gdextension",
+        manifest: {
+          config_version: 1,
+          name: "godot-jolt",
+          entry_symbol: "godot_jolt_main",
+          compatibility: { minimum: "4.1" },
+          libraries: {
+            "windows.x86_64": "bin/godot-jolt.windows.x86_64.dll",
+            "linux.x86_64": "bin/libgodot-jolt.linux.x86_64.so",
+            macos: "bin/libgodot-jolt.macos.universal.dylib"
+          }
+        },
+        isCompatible: true,
+        platforms: ["windows", "linux", "macos"],
+        isInstalled: false,
+        hasNice2DevBinding: true
+      },
+      {
+        name: "terrain3d",
+        manifestPath: "addons/terrain_3d/terrain.gdextension",
+        manifest: {
+          config_version: 1,
+          name: "terrain3d",
+          entry_symbol: "terrain3d_library_init",
+          compatibility: { minimum: "4.1" },
+          libraries: {
+            "windows.x86_64": "bin/libterrain.windows.x86_64.dll",
+            "linux.x86_64": "bin/libterrain.linux.x86_64.so",
+            macos: "bin/libterrain.macos.universal.dylib"
+          }
+        },
+        isCompatible: true,
+        platforms: ["windows", "linux", "macos"],
+        isInstalled: false,
+        hasNice2DevBinding: false
+      },
+      {
+        name: "godotsteam",
+        manifestPath: "addons/godotsteam/godotsteam.gdextension",
+        manifest: {
+          config_version: 1,
+          name: "godotsteam",
+          entry_symbol: "steam_library_init",
+          compatibility: { minimum: "4.1" },
+          libraries: {
+            "windows.x86_64": "bin/godotsteam.windows.x86_64.dll",
+            "linux.x86_64": "bin/libgodotsteam.linux.x86_64.so",
+            macos: "bin/libgodotsteam.macos.universal.dylib"
+          },
+          dependencies: {
+            "windows.x86_64": ["steam_api64.dll"],
+            "linux.x86_64": ["libsteam_api.so"],
+            macos: ["libsteam_api.dylib"]
+          }
+        },
+        isCompatible: true,
+        platforms: ["windows", "linux", "macos"],
+        isInstalled: false,
+        hasNice2DevBinding: true
+      }
+    ];
+    for (const ext of knownExtensions) {
+      this.extensions.set(ext.name, ext);
     }
-    // ─── Extension Management ──────────────────────────────
-    getExtension(name) {
-        return this.extensions.get(name);
-    }
-    getAllExtensions() {
-        return Array.from(this.extensions.values());
-    }
-    getInstalledExtensions() {
-        return Array.from(this.extensions.values()).filter((e) => e.isInstalled);
-    }
-    async parseGDExtensionFile(content) {
-        // GDExtension files are in a INI-like format
-        const manifest = {
-            config_version: 1,
-            name: '',
-            entry_symbol: '',
-            compatibility: { minimum: '4.1' },
-            libraries: {},
-        };
-        let currentSection = '';
-        const lines = content.split('\n');
-        for (let line of lines) {
-            line = line.trim();
-            if (!line || line.startsWith(';')) {
-                continue;
-            }
-            // Section header
-            if (line.startsWith('[') && line.endsWith(']')) {
-                currentSection = line.slice(1, -1);
-                continue;
+  }
+  // ─── Extension Management ──────────────────────────────
+  getExtension(name) {
+    return this.extensions.get(name);
+  }
+  getAllExtensions() {
+    return Array.from(this.extensions.values());
+  }
+  getInstalledExtensions() {
+    return Array.from(this.extensions.values()).filter((e) => e.isInstalled);
+  }
+  async parseGDExtensionFile(content) {
+    const manifest = {
+      config_version: 1,
+      name: "",
+      entry_symbol: "",
+      compatibility: { minimum: "4.1" },
+      libraries: {}
+    };
+    let currentSection = "";
+    const lines = content.split("\n");
+    for (let line of lines) {
+      line = line.trim();
+      if (!line || line.startsWith(";")) {
+        continue;
+      }
+      if (line.startsWith("[") && line.endsWith("]")) {
+        currentSection = line.slice(1, -1);
+        continue;
+      }
+      if (line.includes("=")) {
+        const eqIndex = line.indexOf("=");
+        const key = line.substring(0, eqIndex).trim();
+        let value = line.substring(eqIndex + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"')) {
+          value = value.slice(1, -1);
+        }
+        switch (currentSection) {
+          case "configuration":
+            if (key === "entry_symbol") {
+              manifest.entry_symbol = value;
             }
-            // Key-value pair
-            if (line.includes('=')) {
-                const eqIndex = line.indexOf('=');
-                const key = line.substring(0, eqIndex).trim();
-                let value = line.substring(eqIndex + 1).trim();
-                // Remove quotes
-                if (value.startsWith('"') && value.endsWith('"')) {
-                    value = value.slice(1, -1);
-                }
-                switch (currentSection) {
-                    case 'configuration':
-                        if (key === 'entry_symbol') {
-                            manifest.entry_symbol = value;
-                        }
-                        if (key === 'compatibility_minimum') {
-                            manifest.compatibility.minimum = value;
-                        }
-                        if (key === 'compatibility_maximum') {
-                            manifest.compatibility.maximum = value;
-                        }
-                        if (key === 'reloadable') {
-                            manifest.reloadable = value === 'true';
-                        }
-                        break;
-                    case 'libraries':
-                        manifest.libraries[key] = value;
-                        break;
-                    case 'dependencies':
-                        if (!manifest.dependencies) {
-                            manifest.dependencies = {};
-                        }
-                        manifest.dependencies[key] = value.split(',').map((v) => v.trim());
-                        break;
-                }
+            if (key === "compatibility_minimum") {
+              manifest.compatibility.minimum = value;
             }
-        }
-        return manifest;
-    }
-    checkExtensionCompatibility(manifest, godotVersion) {
-        const minParts = manifest.compatibility.minimum.split('.').map(Number);
-        const versionParts = godotVersion.split('.').map(Number);
-        // Check minimum version
-        for (let i = 0; i < minParts.length; i++) {
-            if (versionParts[i] < minParts[i]) {
-                return false;
+            if (key === "compatibility_maximum") {
+              manifest.compatibility.maximum = value;
             }
-            if (versionParts[i] > minParts[i]) {
-                break;
+            if (key === "reloadable") {
+              manifest.reloadable = value === "true";
             }
-        }
-        // Check maximum version if specified
-        if (manifest.compatibility.maximum) {
-            const maxParts = manifest.compatibility.maximum.split('.').map(Number);
-            for (let i = 0; i < maxParts.length; i++) {
-                if (versionParts[i] > maxParts[i]) {
-                    return false;
-                }
-                if (versionParts[i] < maxParts[i]) {
-                    break;
-                }
+            break;
+          case "libraries":
+            manifest.libraries[key] = value;
+            break;
+          case "dependencies":
+            if (!manifest.dependencies) {
+              manifest.dependencies = {};
             }
+            manifest.dependencies[key] = value.split(",").map((v) => v.trim());
+            break;
         }
-        return true;
-    }
-    // ─── Nice2Dev Bindings ─────────────────────────────────
-    generateBinding(extension) {
-        // In real implementation, parse the extension's API and generate TypeScript bindings
-        const binding = {
-            extensionName: extension.name,
-            types: [],
-            methods: [],
-            signals: [],
-        };
-        // Example bindings for godot-jolt
-        if (extension.name === 'godot-jolt') {
-            binding.types = [
-                {
-                    name: 'JoltPhysicsServer3D',
-                    baseType: 'PhysicsServer3D',
-                    isRefCounted: false,
-                    properties: [],
-                },
-                {
-                    name: 'JoltShapeSettings3D',
-                    baseType: 'Resource',
-                    isRefCounted: true,
-                    properties: [{ name: 'margin', type: 'float', default: '0.04' }],
-                },
-            ];
-        }
-        // Example bindings for godotsteam
-        if (extension.name === 'godotsteam') {
-            binding.types = [
-                {
-                    name: 'Steam',
-                    baseType: 'Object',
-                    isRefCounted: false,
-                    properties: [{ name: 'is_initialized', type: 'bool', getter: 'isSteamRunning' }],
-                },
-            ];
-            binding.methods = [
-                {
-                    name: 'steamInit',
-                    returnType: 'Dictionary',
-                    arguments: [{ name: 'retrieve_stats', type: 'bool', default: 'true' }],
-                    isStatic: true,
-                    isConst: false,
-                    isVirtual: false,
-                },
-                {
-                    name: 'getPersonaName',
-                    returnType: 'String',
-                    arguments: [],
-                    isStatic: false,
-                    isConst: true,
-                    isVirtual: false,
-                },
-                {
-                    name: 'setAchievement',
-                    returnType: 'bool',
-                    arguments: [{ name: 'achievement_name', type: 'String' }],
-                    isStatic: false,
-                    isConst: false,
-                    isVirtual: false,
-                },
-            ];
-            binding.signals = [
-                {
-                    name: 'overlay_toggled',
-                    arguments: [{ name: 'active', type: 'bool' }],
-                },
-                {
-                    name: 'current_stats_received',
-                    arguments: [
-                        { name: 'game_id', type: 'int' },
-                        { name: 'result', type: 'int' },
-                    ],
-                },
-            ];
-        }
-        this.bindings.set(extension.name, binding);
-        return binding;
-    }
-    getBinding(extensionName) {
-        return this.bindings.get(extensionName);
-    }
-    generateTypeScriptDefinitions(binding) {
-        let output = `// Nice2Dev GDExtension Bindings for ${binding.extensionName}\n\n`;
-        // Generate types
-        for (const type of binding.types) {
-            output += `export interface ${type.name} extends ${type.baseType} {\n`;
-            for (const prop of type.properties) {
-                output += `  ${prop.name}: ${this.mapGodotTypeToTS(prop.type)};\n`;
-            }
-            output += `}\n\n`;
-        }
-        // Generate method declarations
-        if (binding.methods.length > 0) {
-            output += `export interface ${binding.extensionName}Methods {\n`;
-            for (const method of binding.methods) {
-                const params = method.arguments
-                    .map((a) => `${a.name}: ${this.mapGodotTypeToTS(a.type)}`)
-                    .join(', ');
-                const returnType = this.mapGodotTypeToTS(method.returnType);
-                output += `  ${method.name}(${params}): ${returnType};\n`;
-            }
-            output += `}\n\n`;
+      }
+    }
+    return manifest;
+  }
+  checkExtensionCompatibility(manifest, godotVersion) {
+    const minParts = manifest.compatibility.minimum.split(".").map(Number);
+    const versionParts = godotVersion.split(".").map(Number);
+    for (let i = 0; i < minParts.length; i++) {
+      if (versionParts[i] < minParts[i]) {
+        return false;
+      }
+      if (versionParts[i] > minParts[i]) {
+        break;
+      }
+    }
+    if (manifest.compatibility.maximum) {
+      const maxParts = manifest.compatibility.maximum.split(".").map(Number);
+      for (let i = 0; i < maxParts.length; i++) {
+        if (versionParts[i] > maxParts[i]) {
+          return false;
         }
-        // Generate signal declarations
-        if (binding.signals.length > 0) {
-            output += `export interface ${binding.extensionName}Signals {\n`;
-            for (const signal of binding.signals) {
-                const params = signal.arguments
-                    .map((a) => `${a.name}: ${this.mapGodotTypeToTS(a.type)}`)
-                    .join(', ');
-                output += `  ${signal.name}: (${params}) => void;\n`;
-            }
-            output += `}\n`;
+        if (versionParts[i] < maxParts[i]) {
+          break;
         }
-        return output;
-    }
-    mapGodotTypeToTS(godotType) {
-        const typeMap = {
-            void: 'void',
-            bool: 'boolean',
-            int: 'number',
-            float: 'number',
-            String: 'string',
-            StringName: 'string',
-            NodePath: 'string',
-            Vector2: '{ x: number; y: number }',
-            Vector2i: '{ x: number; y: number }',
-            Vector3: '{ x: number; y: number; z: number }',
-            Vector3i: '{ x: number; y: number; z: number }',
-            Vector4: '{ x: number; y: number; z: number; w: number }',
-            Color: '{ r: number; g: number; b: number; a: number }',
-            Rect2: '{ x: number; y: number; width: number; height: number }',
-            Transform2D: 'Transform2D',
-            Transform3D: 'Transform3D',
-            Array: 'unknown[]',
-            Dictionary: 'Record<string, unknown>',
-            Object: 'unknown',
-            Resource: 'unknown',
-        };
-        return typeMap[godotType] ?? godotType;
-    }
-    // ─── Callbacks ─────────────────────────────────────────
-    setCallbacks(callbacks) {
-        this.callbacks = { ...this.callbacks, ...callbacks };
+      }
+    }
+    return true;
+  }
+  // ─── Nice2Dev Bindings ─────────────────────────────────
+  generateBinding(extension) {
+    const binding = {
+      extensionName: extension.name,
+      types: [],
+      methods: [],
+      signals: []
+    };
+    if (extension.name === "godot-jolt") {
+      binding.types = [
+        {
+          name: "JoltPhysicsServer3D",
+          baseType: "PhysicsServer3D",
+          isRefCounted: false,
+          properties: []
+        },
+        {
+          name: "JoltShapeSettings3D",
+          baseType: "Resource",
+          isRefCounted: true,
+          properties: [{ name: "margin", type: "float", default: "0.04" }]
+        }
+      ];
     }
+    if (extension.name === "godotsteam") {
+      binding.types = [
+        {
+          name: "Steam",
+          baseType: "Object",
+          isRefCounted: false,
+          properties: [{ name: "is_initialized", type: "bool", getter: "isSteamRunning" }]
+        }
+      ];
+      binding.methods = [
+        {
+          name: "steamInit",
+          returnType: "Dictionary",
+          arguments: [{ name: "retrieve_stats", type: "bool", default: "true" }],
+          isStatic: true,
+          isConst: false,
+          isVirtual: false
+        },
+        {
+          name: "getPersonaName",
+          returnType: "String",
+          arguments: [],
+          isStatic: false,
+          isConst: true,
+          isVirtual: false
+        },
+        {
+          name: "setAchievement",
+          returnType: "bool",
+          arguments: [{ name: "achievement_name", type: "String" }],
+          isStatic: false,
+          isConst: false,
+          isVirtual: false
+        }
+      ];
+      binding.signals = [
+        {
+          name: "overlay_toggled",
+          arguments: [{ name: "active", type: "bool" }]
+        },
+        {
+          name: "current_stats_received",
+          arguments: [
+            { name: "game_id", type: "int" },
+            { name: "result", type: "int" }
+          ]
+        }
+      ];
+    }
+    this.bindings.set(extension.name, binding);
+    return binding;
+  }
+  getBinding(extensionName) {
+    return this.bindings.get(extensionName);
+  }
+  generateTypeScriptDefinitions(binding) {
+    let output = `// Nice2Dev GDExtension Bindings for ${binding.extensionName}
+
+`;
+    for (const type of binding.types) {
+      output += `export interface ${type.name} extends ${type.baseType} {
+`;
+      for (const prop of type.properties) {
+        output += `  ${prop.name}: ${this.mapGodotTypeToTS(prop.type)};
+`;
+      }
+      output += `}
+
+`;
+    }
+    if (binding.methods.length > 0) {
+      output += `export interface ${binding.extensionName}Methods {
+`;
+      for (const method of binding.methods) {
+        const params = method.arguments.map((a) => `${a.name}: ${this.mapGodotTypeToTS(a.type)}`).join(", ");
+        const returnType = this.mapGodotTypeToTS(method.returnType);
+        output += `  ${method.name}(${params}): ${returnType};
+`;
+      }
+      output += `}
+
+`;
+    }
+    if (binding.signals.length > 0) {
+      output += `export interface ${binding.extensionName}Signals {
+`;
+      for (const signal of binding.signals) {
+        const params = signal.arguments.map((a) => `${a.name}: ${this.mapGodotTypeToTS(a.type)}`).join(", ");
+        output += `  ${signal.name}: (${params}) => void;
+`;
+      }
+      output += `}
+`;
+    }
+    return output;
+  }
+  mapGodotTypeToTS(godotType) {
+    const typeMap = {
+      void: "void",
+      bool: "boolean",
+      int: "number",
+      float: "number",
+      String: "string",
+      StringName: "string",
+      NodePath: "string",
+      Vector2: "{ x: number; y: number }",
+      Vector2i: "{ x: number; y: number }",
+      Vector3: "{ x: number; y: number; z: number }",
+      Vector3i: "{ x: number; y: number; z: number }",
+      Vector4: "{ x: number; y: number; z: number; w: number }",
+      Color: "{ r: number; g: number; b: number; a: number }",
+      Rect2: "{ x: number; y: number; width: number; height: number }",
+      Transform2D: "Transform2D",
+      Transform3D: "Transform3D",
+      Array: "unknown[]",
+      Dictionary: "Record<string, unknown>",
+      Object: "unknown",
+      Resource: "unknown"
+    };
+    return typeMap[godotType] ?? godotType;
+  }
+  // ─── Callbacks ─────────────────────────────────────────
+  setCallbacks(callbacks) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createGodotAssetLibraryBrowser(config) {
-    return new GodotAssetLibraryBrowser(config);
+  return new GodotAssetLibraryBrowser(config);
 }
 function createGDExtensionManager() {
-    return new GDExtensionManager();
+  return new GDExtensionManager();
 }
-
-export { GDExtensionManager, GodotAssetLibraryBrowser, createGDExtensionManager, createGodotAssetLibraryBrowser };
+export {
+  GDExtensionManager,
+  GodotAssetLibraryBrowser,
+  createGDExtensionManager,
+  createGodotAssetLibraryBrowser
+};