@rynt/sdk 0.9.53

package/src/shared/composables/modsEditor/modsEditor.ts

@@ -0,0 +1,1678 @@
+import { defineStore } from '../../definitions/defineStore';
+import { computed, reactive, ref, watch, type Ref } from 'vue';
+import { debounce } from 'lodash-es';
+import type {
+  BuildVersionManifest,
+  Mod,
+  ResourcePack,
+} from '../../minecraft-types/build-manifest';
+import { useLocalBuildsModel } from '@/models';
+import type {
+  MarketplaceInstallVersion,
+  MarketplaceItem,
+  MarketplaceSearchContext,
+  ProjectType,
+  InstallContext,
+  ProjectDetails,
+} from '../../mods/types';
+import {
+  getModMarketplaceProvider,
+  listModMarketplaceProviders,
+} from '../../mods/mod-marketplace-registry';
+import {
+  mergeMarketplaceItems,
+  runMarketplaceSearch,
+} from '../../mods/marketplace-search-utils';
+import { resolveModsProviderLoaderIds } from '../../mods/resolve-mods-provider-loader-ids';
+
+function withMarketplaceLoaderIdsForProvider<
+  T extends { loader?: string },
+>(ctx: T, providerId: string): T & { marketplaceLoaderIds: string[] } {
+  return {
+    ...ctx,
+    marketplaceLoaderIds: resolveModsProviderLoaderIds(ctx.loader, providerId),
+  };
+}
+import {
+  scanLocalMods,
+  toggleModDisabled,
+  deleteLocalMod,
+} from '../../utils/local-mods';
+
+/** Вкладки: встроенные + id зарегистрированных расширением провайдеров. */
+export type ModsEditorMarketplaceTab = string;
+
+export const useModsEditorModel = defineStore(
+  (_manifestRef: Ref<BuildVersionManifest | null>) => {
+    // Manifest ref - получаем напрямую при создании store
+    const manifest = _manifestRef;
+
+    const searchQuery = ref('');
+    const projectType = ref<ProjectType>('mod');
+    const marketplaceTab = ref<ModsEditorMarketplaceTab>('all');
+
+    const isSearching = ref(false);
+    const searchError = ref<string | null>(null);
+
+    const searchResultsByProvider = reactive<Record<string, MarketplaceItem[]>>(
+      {},
+    );
+    const isSearchingByProvider = reactive<Record<string, boolean>>({});
+    const isLoadingMoreByProvider = reactive<Record<string, boolean>>({});
+    const hasMoreByProvider = reactive<Record<string, boolean>>({});
+    const searchPageByProvider = reactive<Record<string, number>>({});
+    const marketplaceBrowseStarted = ref(false);
+
+    function syncMarketplaceProviderSearchKeys(): void {
+      for (const p of listModMarketplaceProviders()) {
+        if (!(p.id in searchResultsByProvider)) {
+          searchResultsByProvider[p.id] = [];
+        }
+        if (!(p.id in isSearchingByProvider)) {
+          isSearchingByProvider[p.id] = false;
+        }
+        if (!(p.id in isLoadingMoreByProvider)) {
+          isLoadingMoreByProvider[p.id] = false;
+        }
+        if (!(p.id in hasMoreByProvider)) {
+          hasMoreByProvider[p.id] = false;
+        }
+        if (!(p.id in searchPageByProvider)) {
+          searchPageByProvider[p.id] = -1;
+        }
+      }
+    }
+
+    function getProvidersForLoadMore(tabId: string): string[] {
+      syncMarketplaceProviderSearchKeys();
+      if (tabId === 'all') {
+        return listModMarketplaceProviders()
+          .map((p) => p.id)
+          .filter((id) => hasMoreByProvider[id]);
+      }
+      return hasMoreByProvider[tabId] ? [tabId] : [];
+    }
+
+    function canLoadMoreMarketplace(tabId: string): boolean {
+      return getProvidersForLoadMore(tabId).length > 0;
+    }
+
+    function isLoadingMoreMarketplace(tabId: string): boolean {
+      syncMarketplaceProviderSearchKeys();
+      if (tabId === 'all') {
+        return listModMarketplaceProviders().some(
+          (p) => isLoadingMoreByProvider[p.id],
+        );
+      }
+      return Boolean(isLoadingMoreByProvider[tabId]);
+    }
+
+    async function marketplaceItemForProvider(
+      providerId: string,
+      projectId: string,
+      projectType: ProjectType,
+    ): Promise<MarketplaceItem | null> {
+      const prov = getModMarketplaceProvider(providerId);
+      if (!prov) return null;
+      try {
+        const d = await prov.getProjectDetails(projectId);
+        return {
+          provider: d.provider,
+          projectType,
+          projectId: d.projectId,
+          slug: d.slug,
+          name: d.name,
+          summary: d.summary,
+          iconUrl: d.iconUrl,
+          downloads: d.downloads,
+        };
+      } catch (e) {
+        console.warn(
+          `[modsEditor] Could not load marketplace item ${providerId}:${projectId}:`,
+          e,
+        );
+        return null;
+      }
+    }
+
+    const selectedModDetails = ref<ProjectDetails | null>(null);
+    const isLoadingModDetails = ref(false);
+    const modDetailsError = ref<string | null>(null);
+
+    // Incompatibility dialog state
+    const incompatibilityDialog = ref<{
+      open: boolean;
+      incompatibleMod: Mod | null;
+      conflictingMod: Mod | null;
+      resolveCallback: ((proceed: boolean) => void) | null;
+    }>({
+      open: false,
+      incompatibleMod: null,
+      conflictingMod: null,
+      resolveCallback: null,
+    });
+
+    // Dependency removal dialog state
+    const dependencyRemovalDialog = ref<{
+      open: boolean;
+      modToRemove: Mod | null;
+      dependentMods: Mod[];
+      resolveCallback:
+        | ((action: 'cancel' | 'remove-only' | 'remove-all') => void)
+        | null;
+    }>({
+      open: false,
+      modToRemove: null,
+      dependentMods: [],
+      resolveCallback: null,
+    });
+
+    // Version selection dialog state
+    const versionSelectionDialog = ref<{
+      open: boolean;
+      item: MarketplaceItem | null;
+      versions: MarketplaceInstallVersion[];
+      selectedVersionId: string | null;
+      resolveCallback: ((selectedVersionId: string | null) => void) | null;
+    }>({
+      open: false,
+      item: null,
+      versions: [],
+      selectedVersionId: null,
+      resolveCallback: null,
+    });
+
+    // Dependency issues dialog state
+    type DependencyIssue =
+      | {
+          type: 'missing';
+          mod: Mod;
+          dependency: {
+            slug: string;
+            modId: string;
+            source: string;
+            name?: string;
+          };
+        }
+      | { type: 'incompatible'; mod: Mod; conflictingMod: Mod }
+      | { type: 'incompatible-version'; mod: Mod; reason: string }; // Mod incompatible with selected loader/version
+
+    const dependencyIssuesDialog = ref<{
+      open: boolean;
+      issues: DependencyIssue[];
+      isResolving: boolean;
+      isResolved: boolean;
+    }>({
+      open: false,
+      issues: [],
+      isResolving: false,
+      isResolved: false,
+    });
+
+    // Store original manifest for comparing with local mods
+    const originalManifest = ref<BuildVersionManifest | null>(null);
+
+    // Local mods (not in manifest)
+    const localMods = ref<Mod[]>([]);
+    const localResourcePacks = ref<ResourcePack[]>([]);
+
+    // Computed, которые читают напрямую из manifest (теперь работают, т.к. manifest установлен при создании)
+    const installedMods = computed<Mod[]>(
+      () => (manifest.value?.mods ?? []) as Mod[],
+    );
+    const installedResourcePacks = computed<ResourcePack[]>(
+      () => (manifest.value?.resourcePacks ?? []) as ResourcePack[],
+    );
+
+    // All mods including local ones
+    const allMods = computed<Mod[]>(() => [
+      ...installedMods.value,
+      ...localMods.value,
+    ]);
+    const allResourcePacks = computed<ResourcePack[]>(() => [
+      ...installedResourcePacks.value,
+      ...localResourcePacks.value,
+    ]);
+
+    function isInstalledBySlug(slug: string): boolean {
+      if (projectType.value === 'resourcepack') {
+        return installedResourcePacks.value.some(
+          (rp) => rp.projectSlug === slug || rp.id === slug,
+        );
+      }
+      return installedMods.value.some(
+        (m) => m.projectSlug === slug || m.id === slug,
+      );
+    }
+
+    async function searchProvider(
+      providerId: string,
+      reset: boolean,
+      baseSearchCtx: MarketplaceSearchContext,
+    ): Promise<void> {
+      const prov = getModMarketplaceProvider(providerId);
+      if (!prov) return;
+
+      const page = reset ? 0 : (searchPageByProvider[providerId] ?? -1) + 1;
+      const ctx = withMarketplaceLoaderIdsForProvider(
+        { ...baseSearchCtx, page },
+        providerId,
+      );
+
+      if (reset) {
+        isSearchingByProvider[providerId] = true;
+      } else {
+        isLoadingMoreByProvider[providerId] = true;
+      }
+
+      try {
+        const result = await runMarketplaceSearch(prov, ctx);
+        if (reset) {
+          searchResultsByProvider[providerId] = result.items;
+        } else {
+          searchResultsByProvider[providerId] = mergeMarketplaceItems(
+            searchResultsByProvider[providerId] ?? [],
+            result.items,
+          );
+        }
+        hasMoreByProvider[providerId] = result.hasMore;
+        searchPageByProvider[providerId] = page;
+      } catch (e) {
+        console.warn(`[modsEditor] ${providerId} search failed:`, e);
+        if (reset) {
+          searchResultsByProvider[providerId] = [];
+          hasMoreByProvider[providerId] = false;
+          searchPageByProvider[providerId] = -1;
+        }
+      } finally {
+        if (reset) {
+          isSearchingByProvider[providerId] = false;
+        } else {
+          isLoadingMoreByProvider[providerId] = false;
+        }
+      }
+    }
+
+    async function searchProviders(
+      providerIds: string[],
+      reset: boolean,
+    ): Promise<void> {
+      syncMarketplaceProviderSearchKeys();
+      marketplaceBrowseStarted.value = true;
+
+      const q = searchQuery.value;
+      const baseSearchCtx: MarketplaceSearchContext = {
+        projectType: projectType.value,
+        query: q,
+        minecraftVersion:
+          manifest.value?._meta?.manifest?.minecraftVersion || undefined,
+        loader: manifest.value?._meta?.manifest?.loader || undefined,
+      };
+
+      if (reset) {
+        isSearching.value = true;
+        searchError.value = null;
+        for (const id of providerIds) {
+          searchResultsByProvider[id] = [];
+          hasMoreByProvider[id] = false;
+          searchPageByProvider[id] = -1;
+        }
+      }
+
+      try {
+        await Promise.allSettled(
+          providerIds.map((id) => searchProvider(id, reset, baseSearchCtx)),
+        );
+      } catch (e) {
+        searchError.value = e instanceof Error ? e.message : String(e);
+      } finally {
+        if (reset) {
+          isSearching.value = false;
+        }
+      }
+    }
+
+    async function search(reset = true) {
+      const allIds = listModMarketplaceProviders().map((p) => p.id);
+      await searchProviders(allIds, reset);
+    }
+
+    async function loadMoreMarketplaceResults(): Promise<void> {
+      if (isSearching.value) return;
+      const tabId = marketplaceTab.value;
+      const providerIds = getProvidersForLoadMore(tabId);
+      if (!providerIds.length) return;
+      if (isLoadingMoreMarketplace(tabId)) return;
+      await searchProviders(providerIds, false);
+    }
+
+    async function install(
+      item: MarketplaceItem,
+      options?: { skipVersionPrompt?: boolean; selectedVersionId?: string },
+    ) {
+      if (!manifest.value) throw new Error('Manifest is not initialized');
+
+      if (!manifest.value.mods) {
+        manifest.value.mods = [];
+      }
+
+      const mcVersion = manifest.value._meta?.manifest?.minecraftVersion;
+      if (!mcVersion || mcVersion.trim() === '')
+        throw new Error('Select Minecraft version first');
+      const loader = manifest.value._meta?.manifest?.loader;
+      if (!loader || loader.trim() === '')
+        throw new Error('Select loader first');
+
+      const baseInstallCtx: InstallContext = {
+        projectType: projectType.value,
+        minecraftVersion:
+          manifest.value?._meta?.manifest?.minecraftVersion || '',
+        loader: manifest.value?._meta?.manifest?.loader || 'vanilla',
+      };
+      const installCtx = withMarketplaceLoaderIdsForProvider(
+        baseInstallCtx,
+        item.provider,
+      );
+
+      let selectedVersionId: string | undefined = options?.selectedVersionId;
+      const shouldSelectVersion =
+        !selectedVersionId &&
+        !options?.skipVersionPrompt &&
+        projectType.value === 'mod';
+      if (shouldSelectVersion) {
+        const prov = getModMarketplaceProvider(item.provider);
+        if (prov?.getInstallVersions) {
+          const versions = await prov.getInstallVersions(
+            item.projectId,
+            installCtx,
+          );
+          if (versions.length > 1) {
+            const selected = await showVersionSelectionDialog(item, versions);
+            if (!selected) {
+              return;
+            }
+            selectedVersionId = selected;
+          }
+        }
+      }
+
+      let entry: Mod | ResourcePack;
+      try {
+        const prov = getModMarketplaceProvider(item.provider);
+        if (!prov) {
+          throw new Error(`Unknown marketplace provider: ${item.provider}`);
+        }
+        entry = await prov.install(item, installCtx, selectedVersionId);
+      } catch (error) {
+        throw error;
+      }
+
+      if (projectType.value === 'resourcepack') {
+        const rp = entry as ResourcePack;
+        const next = [...(manifest.value.resourcePacks ?? [])].filter(
+          (x) => x.id !== rp.id, // Use id (projectId) for comparison
+        );
+        next.push(rp);
+        manifest.value.resourcePacks = next;
+        return;
+      }
+
+      const mod = entry as Mod;
+
+      // Resolve all required dependencies first
+      const dependencies = await resolveDependencies(mod, installCtx);
+
+      // Check for incompatibilities with all mods that will be installed (main mod + dependencies)
+      const modsToCheck = [mod, ...dependencies];
+      const currentInstalledMods = manifest.value.mods ?? [];
+
+      for (const modToCheck of modsToCheck) {
+        const { conflictingMod } = checkIncompatibilities(
+          modToCheck,
+          currentInstalledMods,
+        );
+        if (conflictingMod) {
+          const proceed = await showIncompatibilityDialog(
+            modToCheck,
+            conflictingMod,
+          );
+          if (!proceed) {
+            return; // User cancelled installation
+          }
+        }
+
+        // Also check for incompatibilities between mods being installed
+        for (const otherMod of modsToCheck) {
+          if (modToCheck.id === otherMod.id) continue; // Skip self
+
+          const { conflictingMod: conflict } = checkIncompatibilities(
+            modToCheck,
+            [otherMod],
+          );
+          if (conflict) {
+            const proceed = await showIncompatibilityDialog(
+              modToCheck,
+              conflict,
+            );
+            if (!proceed) {
+              return; // User cancelled installation
+            }
+          }
+        }
+      }
+
+      // Add all dependencies first
+      const allModsToInstall = [...installedMods.value];
+      for (const depMod of dependencies) {
+        // Remove if already exists (update) - use id (projectId) for comparison
+        const existingIndex = allModsToInstall.findIndex(
+          (m) => m.id === depMod.id,
+        );
+        if (existingIndex >= 0) {
+          allModsToInstall[existingIndex] = depMod;
+        } else {
+          allModsToInstall.push(depMod);
+        }
+      }
+
+      // Add/update the main mod - use id (projectId) for comparison
+      const mainModIndex = allModsToInstall.findIndex((m) => m.id === mod.id);
+
+      // Update dependencies of main mod with actual installed versions
+      if (mod.dependencies && mod.dependencies.length > 0) {
+        mod.dependencies = mod.dependencies.map((dep) => {
+          // First, try to find in newly installed dependencies
+          const installedDep = dependencies.find(
+            (m) => m.id === dep.modId || m.projectSlug === dep.slug,
+          );
+          if (installedDep) {
+            return {
+              ...dep,
+              version: installedDep.version, // Use actual installed dependency version
+            };
+          }
+
+          // If not found in new dependencies, check already installed mods
+          const existingDep = allModsToInstall.find(
+            (m) => m.id === dep.modId || m.projectSlug === dep.slug,
+          );
+          if (existingDep) {
+            return {
+              ...dep,
+              version: existingDep.version, // Use version of already installed dependency
+            };
+          }
+
+          // If dependency not found (shouldn't happen for required deps), keep original
+          return dep;
+        });
+      }
+
+      if (mainModIndex >= 0) {
+        allModsToInstall[mainModIndex] = mod;
+      } else {
+        allModsToInstall.push(mod);
+      }
+
+      console.log('[modsEditor.install] Добавляем мод:', {
+        modId: mod.id,
+        modName: mod.name,
+        allModsToInstallCount: allModsToInstall.length,
+        installedModsCountBefore: installedMods.value.length,
+        manifestValueExists: !!manifest.value,
+        manifestModsExists: !!manifest.value?.mods,
+      });
+
+      // Убеждаемся, что массив mods инициализирован
+      if (!manifest.value.mods) {
+        manifest.value.mods = [];
+      }
+
+      // Обновляем массив модов - Vue должен отследить изменение
+      manifest.value.mods = [...allModsToInstall];
+
+      console.log('[modsEditor.install] После добавления:', {
+        manifestModsCount: manifest.value.mods?.length ?? 0,
+        installedModsCountAfter: installedMods.value.length,
+        allModsComputedCount: allMods.value.length,
+      });
+    }
+
+    /**
+     * Find all mods that depend on the given mod
+     * Uses slug for matching (as per new dependency format)
+     */
+    function findDependentMods(mod: Mod): Mod[] {
+      const installed = installedMods.value;
+      const dependent: Mod[] = [];
+
+      for (const installedMod of installed) {
+        if (
+          installedMod.id === mod.id ||
+          installedMod.projectSlug === mod.projectSlug
+        ) {
+          continue; // Skip the mod itself
+        }
+
+        // Check if this mod has a required dependency on the mod we're removing
+        // Match by slug (primary) or fallback to modId for backwards compatibility
+        const hasRequiredDep = installedMod.dependencies?.some(
+          (dep) =>
+            dep.type === 'required' &&
+            (dep.slug === mod.projectSlug ||
+              dep.modId === mod.id ||
+              dep.modId === mod.projectSlug),
+        );
+
+        if (hasRequiredDep) {
+          dependent.push(installedMod);
+        }
+      }
+
+      return dependent;
+    }
+
+    /**
+     * Find all mods that can be safely removed (no one depends on them)
+     * Recursively finds orphaned dependencies that were installed only for the removed mod
+     */
+    function findOrphanedDependencies(
+      removedMod: Mod,
+      remainingMods: Mod[],
+    ): Mod[] {
+      const orphaned: Mod[] = [];
+      const processed = new Set<string>();
+
+      function findOrphans(currentMod: Mod) {
+        const modKey = `${currentMod.source}:${currentMod.projectSlug || currentMod.id}`;
+        if (processed.has(modKey)) return;
+        processed.add(modKey);
+
+        // Check if anyone in remaining mods depends on this mod
+        // Use slug for matching (as per new dependency format)
+        const hasDependents = remainingMods.some((m) => {
+          if (m.id === currentMod.id) return false;
+          return m.dependencies?.some(
+            (dep) =>
+              dep.type === 'required' &&
+              (dep.slug === currentMod.projectSlug ||
+                dep.modId === currentMod.id),
+          );
+        });
+
+        if (!hasDependents) {
+          // This mod is orphaned - no one depends on it
+          orphaned.push(currentMod);
+
+          // Recursively check this mod's dependencies (they might also be orphaned)
+          const requiredDeps =
+            currentMod.dependencies?.filter((d) => d.type === 'required') ?? [];
+          for (const dep of requiredDeps) {
+            // Find dependency mod by slug (primary) or modId (fallback)
+            const depMod = remainingMods.find(
+              (m) => m.projectSlug === dep.slug || m.id === dep.modId,
+            );
+            if (depMod) {
+              findOrphans(depMod);
+            }
+          }
+        }
+      }
+
+      // Start from the removed mod's dependencies
+      const requiredDeps =
+        removedMod.dependencies?.filter((d) => d.type === 'required') ?? [];
+      for (const dep of requiredDeps) {
+        const depMod = remainingMods.find(
+          (m) => m.projectSlug === dep.modId || m.id === dep.modId,
+        );
+        if (depMod) {
+          findOrphans(depMod);
+        }
+      }
+
+      return orphaned;
+    }
+
+    /**
+     * Show dependency removal dialog and wait for user decision
+     */
+    function showDependencyRemovalDialog(
+      modToRemove: Mod,
+      dependentMods: Mod[],
+    ): Promise<'cancel' | 'remove-only' | 'remove-all'> {
+      return new Promise((resolve) => {
+        dependencyRemovalDialog.value = {
+          open: true,
+          modToRemove,
+          dependentMods,
+          resolveCallback: resolve,
+        };
+      });
+    }
+
+    function handleDependencyRemovalCancel() {
+      if (dependencyRemovalDialog.value.resolveCallback) {
+        dependencyRemovalDialog.value.resolveCallback('cancel');
+      }
+      dependencyRemovalDialog.value = {
+        open: false,
+        modToRemove: null,
+        dependentMods: [],
+        resolveCallback: null,
+      };
+    }
+
+    function handleDependencyRemovalOnly() {
+      if (dependencyRemovalDialog.value.resolveCallback) {
+        dependencyRemovalDialog.value.resolveCallback('remove-only');
+      }
+      dependencyRemovalDialog.value = {
+        open: false,
+        modToRemove: null,
+        dependentMods: [],
+        resolveCallback: null,
+      };
+    }
+
+    function handleDependencyRemovalAll() {
+      if (dependencyRemovalDialog.value.resolveCallback) {
+        dependencyRemovalDialog.value.resolveCallback('remove-all');
+      }
+      dependencyRemovalDialog.value = {
+        open: false,
+        modToRemove: null,
+        dependentMods: [],
+        resolveCallback: null,
+      };
+    }
+
+    /**
+     * Check if a mod has all its required dependencies installed
+     * Uses slug and version for matching (as per new dependency format)
+     */
+    function checkModDependenciesStatus(mod: Mod): {
+      isValid: boolean;
+      missingDependencies: string[];
+    } {
+      const missing: string[] = [];
+      const installed = installedMods.value;
+      const currentMc = manifest.value?._meta?.manifest?.minecraftVersion || '';
+      const currentLoader =
+        manifest.value?._meta?.manifest?.loader || 'vanilla';
+
+      // Check compatibility with selected loader and Minecraft version
+      if (mod.constraints) {
+        const mcMatch = mod.constraints.minecraft === currentMc;
+        const loaderMatch = mod.constraints.loader === currentLoader;
+
+        if (!mcMatch || !loaderMatch) {
+          // Add compatibility issue to missing dependencies for UI display
+          const reasons: string[] = [];
+          if (!mcMatch) {
+            reasons.push(
+              `Minecraft ${mod.constraints.minecraft} (выбрано: ${currentMc})`,
+            );
+          }
+          if (!loaderMatch) {
+            reasons.push(
+              `Loader ${mod.constraints.loader} (выбран: ${currentLoader})`,
+            );
+          }
+          missing.push(`Несовместимость: ${reasons.join(', ')}`);
+        }
+      }
+
+      const requiredDeps =
+        mod.dependencies?.filter((d) => d.type === 'required') ?? [];
+
+      for (const dep of requiredDeps) {
+        // Check by slug (primary check) and optionally by version
+        const isInstalled = installed.some((installedMod) => {
+          const slugMatch = installedMod.projectSlug === dep.slug;
+          if (!slugMatch) return false;
+
+          // If version is specified in dependency, check version compatibility
+          // For now, we just check if slug matches (version range checking can be added later)
+          return true;
+        });
+
+        if (!isInstalled) {
+          missing.push(dep.slug || dep.modId);
+        }
+      }
+
+      return {
+        isValid: missing.length === 0,
+        missingDependencies: missing,
+      };
+    }
+
+    /**
+     * Get dependency status for all installed mods
+     */
+    const modsDependencyStatus = computed(() => {
+      const status = new Map<
+        string,
+        { isValid: boolean; missingDependencies: string[] }
+      >();
+      const installed = installedMods.value;
+      const currentMc = manifest.value?._meta?.manifest?.minecraftVersion || '';
+      const currentLoader =
+        manifest.value?._meta?.manifest?.loader || 'vanilla';
+
+      for (const mod of installed) {
+        const modKey = mod.id || mod.projectSlug;
+        const modStatus = checkModDependenciesStatus(mod);
+        status.set(modKey, modStatus);
+      }
+
+      return status;
+    });
+
+    /**
+     * Collect all dependency issues (missing dependencies and incompatibilities)
+     */
+    function collectAllDependencyIssues(): DependencyIssue[] {
+      const issues: DependencyIssue[] = [];
+      const installed = installedMods.value;
+      const currentMc = manifest.value?._meta?.manifest?.minecraftVersion || '';
+      const currentLoader =
+        manifest.value?._meta?.manifest?.loader || 'vanilla';
+
+      for (const mod of installed) {
+        // Check compatibility with selected loader and Minecraft version
+        if (mod.constraints) {
+          const mcMatch = mod.constraints.minecraft === currentMc;
+          const loaderMatch = mod.constraints.loader === currentLoader;
+
+          if (!mcMatch || !loaderMatch) {
+            const reasons: string[] = [];
+            if (!mcMatch) {
+              reasons.push(
+                `Minecraft ${mod.constraints.minecraft} (выбрано: ${currentMc})`,
+              );
+            }
+            if (!loaderMatch) {
+              reasons.push(
+                `${mod.constraints.loader} (выбран: ${currentLoader})`,
+              );
+            }
+
+            issues.push({
+              type: 'incompatible-version',
+              mod,
+              reason: `Несовместим с выбранными настройками: ${reasons.join(', ')}`,
+            });
+            // TODO: Implement auto-resolve: search for compatible version of this mod for current loader/version
+            continue; // Skip other checks for incompatible mods
+          }
+        }
+
+        // Check for missing required dependencies
+        const requiredDeps =
+          mod.dependencies?.filter((d) => d.type === 'required') ?? [];
+        for (const dep of requiredDeps) {
+          const isInstalled = installed.some(
+            (installedMod) =>
+              installedMod.projectSlug === dep.slug ||
+              installedMod.id === dep.modId,
+          );
+          if (!isInstalled) {
+            issues.push({
+              type: 'missing',
+              mod,
+              dependency: {
+                slug: dep.slug,
+                modId: dep.modId,
+                source: dep.source,
+              },
+            });
+          }
+        }
+
+        // Check for incompatibilities
+        const incompatibleDeps =
+          mod.dependencies?.filter((d) => d.type === 'incompatible') ?? [];
+        for (const dep of incompatibleDeps) {
+          const conflicting = installed.find(
+            (installedMod) =>
+              installedMod.projectSlug === dep.slug ||
+              installedMod.id === dep.modId,
+          );
+          if (conflicting) {
+            issues.push({
+              type: 'incompatible',
+              mod,
+              conflictingMod: conflicting,
+            });
+          }
+        }
+      }
+
+      return issues;
+    }
+
+    /**
+     * Open dependency issues dialog
+     */
+    function openDependencyIssuesDialog() {
+      const issues = collectAllDependencyIssues();
+      dependencyIssuesDialog.value = {
+        open: true,
+        issues,
+        isResolving: false,
+        isResolved: false,
+      };
+    }
+
+    /**
+     * Close dependency issues dialog
+     */
+    function closeDependencyIssuesDialog() {
+      dependencyIssuesDialog.value = {
+        open: false,
+        issues: [],
+        isResolving: false,
+        isResolved: false,
+      };
+    }
+
+    /**
+     * Resolve a single issue (install missing dependency or remove incompatible mod)
+     */
+    async function resolveIssue(issue: DependencyIssue) {
+      if (!manifest.value) return;
+      const mc = manifest.value._meta?.manifest?.minecraftVersion;
+      const loader = manifest.value._meta?.manifest?.loader;
+      if (!mc || !loader) return;
+
+      dependencyIssuesDialog.value.isResolving = true;
+
+      try {
+        if (issue.type === 'missing') {
+          // Install missing dependency
+          const installCtx = {
+            projectType: projectType.value,
+            minecraftVersion:
+              manifest.value?._meta?.manifest?.minecraftVersion || '',
+            loader: manifest.value?._meta?.manifest?.loader || 'vanilla',
+          } as const;
+
+          let depItem: MarketplaceItem | null = null;
+          depItem = await marketplaceItemForProvider(
+            issue.dependency.source,
+            issue.dependency.modId,
+            installCtx.projectType,
+          );
+
+          if (depItem) {
+            await install(depItem, { skipVersionPrompt: true });
+            issue.dependency.name = depItem.name;
+          } else {
+            console.warn(
+              `[modsEditor] Could not resolve dependency ${issue.dependency.modId} from ${issue.dependency.source}`,
+            );
+          }
+        } else if (issue.type === 'incompatible') {
+          // Remove incompatible mod
+          await removeInstalled(issue.conflictingMod.id);
+        } else if (issue.type === 'incompatible-version') {
+          // Remove mod incompatible with selected loader/version
+          // TODO: Implement auto-resolve: search for compatible version of this mod for current loader/version
+          await removeInstalled(issue.mod.id);
+        }
+
+        // Refresh issues after resolution (wait a bit for reactive updates)
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        const updatedIssues = collectAllDependencyIssues();
+        dependencyIssuesDialog.value.issues = updatedIssues;
+        dependencyIssuesDialog.value.isResolved = updatedIssues.length === 0;
+      } catch (error) {
+        console.error('[modsEditor] Error resolving issue:', error);
+      } finally {
+        dependencyIssuesDialog.value.isResolving = false;
+      }
+    }
+
+    /**
+     * Resolve all issues automatically
+     */
+    async function resolveAllIssues() {
+      if (!manifest.value) {
+        return;
+      }
+      const mc = manifest.value._meta?.manifest?.minecraftVersion;
+      const loader = manifest.value._meta?.manifest?.loader;
+      if (!mc || !loader) {
+        return;
+      }
+
+      dependencyIssuesDialog.value.isResolving = true;
+
+      try {
+        const issues = [...dependencyIssuesDialog.value.issues];
+        const installCtx = {
+          projectType: projectType.value,
+          minecraftVersion:
+            manifest.value?._meta?.manifest?.minecraftVersion || '',
+          loader: manifest.value?._meta?.manifest?.loader || 'vanilla',
+        } as const;
+
+        // Resolve issues in order: first install missing dependencies, then remove incompatibilities
+        const missingIssues = issues.filter((i) => i.type === 'missing');
+        const incompatibleIssues = issues.filter(
+          (i) => i.type === 'incompatible',
+        );
+        const incompatibleVersionIssues = issues.filter(
+          (i) => i.type === 'incompatible-version',
+        );
+
+        // Install missing dependencies first
+        for (const issue of missingIssues) {
+          if (issue.type === 'missing') {
+            let depItem: MarketplaceItem | null = null;
+            depItem = await marketplaceItemForProvider(
+              issue.dependency.source,
+              issue.dependency.modId,
+              installCtx.projectType,
+            );
+
+            if (depItem) {
+              await install(depItem, { skipVersionPrompt: true });
+            }
+          }
+        }
+
+        // Then remove incompatibilities
+        for (const issue of incompatibleIssues) {
+          if (issue.type === 'incompatible') {
+            await removeInstalled(issue.conflictingMod.id);
+          }
+        }
+
+        // Remove incompatible-version mods (mods incompatible with selected loader/version)
+        for (const issue of incompatibleVersionIssues) {
+          if (issue.type === 'incompatible-version') {
+            // TODO: Implement auto-resolve: search for compatible version of this mod for current loader/version
+            await removeInstalled(issue.mod.id);
+          }
+        }
+
+        // Final check (wait a bit for reactive updates)
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        const updatedIssues = collectAllDependencyIssues();
+
+        dependencyIssuesDialog.value.issues = updatedIssues;
+        dependencyIssuesDialog.value.isResolved = updatedIssues.length === 0;
+      } catch (error) {
+        console.error('[modsEditor] Error resolving all issues:', error);
+      } finally {
+        dependencyIssuesDialog.value.isResolving = false;
+      }
+    }
+
+    async function removeInstalled(idOrSlug: string) {
+      if (!manifest.value) return;
+      if (projectType.value === 'resourcepack') {
+        manifest.value.resourcePacks = (
+          manifest.value.resourcePacks ?? []
+        ).filter(
+          (rp) => rp.id !== idOrSlug && rp.projectSlug !== idOrSlug, // Support both id and slug for lookup
+        );
+        return;
+      }
+
+      const allMods = manifest.value.mods ?? [];
+      // Support lookup by id (projectId) or slug
+      const modToRemove = allMods.find(
+        (m) => m.id === idOrSlug || m.projectSlug === idOrSlug,
+      );
+
+      if (!modToRemove) {
+        console.warn('[modsEditor] Mod not found for removal:', idOrSlug);
+        return;
+      }
+
+      // Check if anyone depends on this mod
+      const dependentMods = findDependentMods(modToRemove);
+      console.log(
+        '[modsEditor] Removing mod:',
+        modToRemove.name,
+        'Dependent mods found:',
+        dependentMods.length,
+        dependentMods.map((m) => m.name),
+      );
+
+      if (dependentMods.length > 0) {
+        // Show dialog to choose action
+        console.log('[modsEditor] Showing dependency removal dialog');
+        const action = await showDependencyRemovalDialog(
+          modToRemove,
+          dependentMods,
+        );
+        console.log('[modsEditor] User action:', action);
+
+        if (action === 'cancel') {
+          return; // User cancelled
+        }
+
+        if (action === 'remove-all') {
+          // Remove the mod and all dependent mods - use id (projectId) for comparison
+          const toRemoveIds = new Set([
+            modToRemove.id,
+            ...dependentMods.map((m) => m.id),
+          ]);
+
+          let remainingMods = allMods.filter((m) => !toRemoveIds.has(m.id));
+
+          // Also remove orphaned dependencies recursively for all removed mods
+          const allRemovedMods = [modToRemove, ...dependentMods];
+          const allOrphanedIds = new Set<string>();
+
+          for (const removedMod of allRemovedMods) {
+            const orphaned = findOrphanedDependencies(
+              removedMod,
+              remainingMods,
+            );
+            for (const orphan of orphaned) {
+              allOrphanedIds.add(orphan.id); // Use id (projectId) for comparison
+            }
+            // Update remaining mods after each check to avoid counting already-orphaned mods
+            remainingMods = remainingMods.filter(
+              (m) => !allOrphanedIds.has(m.id),
+            );
+          }
+
+          // Files will be deleted when manifest is saved
+          manifest.value.mods = remainingMods;
+        } else {
+          // Remove only this mod (user chose to keep dependent mods, even if they might break)
+          // Files will be deleted when manifest is saved
+          manifest.value.mods = allMods.filter(
+            (m) => m.id !== idOrSlug && m.projectSlug !== idOrSlug, // Support both id and slug for lookup
+          );
+        }
+      } else {
+        // No one depends on this mod, safe to remove
+        // Also remove orphaned dependencies
+        const remainingMods = allMods.filter(
+          (m) => m.id !== idOrSlug && m.projectSlug !== idOrSlug, // Support both id and slug for lookup
+        );
+        const orphaned = findOrphanedDependencies(modToRemove, remainingMods);
+        const orphanedIds = new Set(orphaned.map((m) => m.id)); // Use id (projectId) for comparison
+
+        // Files will be deleted when manifest is saved
+        manifest.value.mods = remainingMods.filter(
+          (m) => !orphanedIds.has(m.id),
+        );
+      }
+    }
+
+    async function changeInstalledModVersion(mod: Mod) {
+      if (mod.source !== 'modrinth' && mod.source !== 'curseforge') {
+        return;
+      }
+
+      const baseInstallCtx: InstallContext = {
+        projectType: 'mod',
+        minecraftVersion:
+          manifest.value?._meta?.manifest?.minecraftVersion || '',
+        loader: manifest.value?._meta?.manifest?.loader || 'vanilla',
+      };
+      const installCtx = withMarketplaceLoaderIdsForProvider(
+        baseInstallCtx,
+        mod.source,
+      );
+
+      const prov = getModMarketplaceProvider(mod.source);
+      if (!prov?.getInstallVersions) {
+        return;
+      }
+
+      const versions = await prov.getInstallVersions(mod.id, installCtx);
+      if (!versions.length) {
+        return;
+      }
+
+      let selectedVersionId = versions.find((v) => v.label === mod.version)?.id;
+      if (versions.length > 1) {
+        selectedVersionId =
+          (await showVersionSelectionDialog(
+            {
+              provider: mod.source,
+              projectType: 'mod',
+              projectId: mod.id,
+              slug: mod.projectSlug || mod.id,
+              name: mod.name,
+              iconUrl: mod.image,
+            },
+            versions,
+          )) ?? undefined;
+        if (!selectedVersionId) {
+          return;
+        }
+      }
+
+      await install(
+        {
+          provider: mod.source,
+          projectType: 'mod',
+          projectId: mod.id,
+          slug: mod.projectSlug || mod.id,
+          name: mod.name,
+          iconUrl: mod.image,
+        },
+        {
+          skipVersionPrompt: true,
+          selectedVersionId: selectedVersionId ?? versions[0].id,
+        },
+      );
+    }
+
+    function showVersionSelectionDialog(
+      item: MarketplaceItem,
+      versions: MarketplaceInstallVersion[],
+    ): Promise<string | null> {
+      return new Promise((resolve) => {
+        versionSelectionDialog.value = {
+          open: true,
+          item,
+          versions,
+          selectedVersionId:
+            versions.find((v) => v.recommended)?.id ?? versions[0]?.id ?? null,
+          resolveCallback: resolve,
+        };
+      });
+    }
+
+    function closeVersionSelectionDialog() {
+      if (versionSelectionDialog.value.resolveCallback) {
+        versionSelectionDialog.value.resolveCallback(null);
+      }
+      versionSelectionDialog.value = {
+        open: false,
+        item: null,
+        versions: [],
+        selectedVersionId: null,
+        resolveCallback: null,
+      };
+    }
+
+    function confirmVersionSelectionDialog() {
+      if (versionSelectionDialog.value.resolveCallback) {
+        versionSelectionDialog.value.resolveCallback(
+          versionSelectionDialog.value.selectedVersionId,
+        );
+      }
+      versionSelectionDialog.value = {
+        open: false,
+        item: null,
+        versions: [],
+        selectedVersionId: null,
+        resolveCallback: null,
+      };
+    }
+
+    async function loadModDetails(item: MarketplaceItem) {
+      isLoadingModDetails.value = true;
+      modDetailsError.value = null;
+      try {
+        const prov = getModMarketplaceProvider(item.provider);
+        if (!prov) {
+          throw new Error(`Unknown provider: ${item.provider}`);
+        }
+        const details = await prov.getProjectDetails(item.projectId);
+        selectedModDetails.value = details;
+      } catch (e) {
+        modDetailsError.value = e instanceof Error ? e.message : String(e);
+        selectedModDetails.value = null;
+      } finally {
+        isLoadingModDetails.value = false;
+      }
+    }
+
+    async function loadInstalledModDetails(mod: Mod) {
+      isLoadingModDetails.value = true;
+      modDetailsError.value = null;
+      try {
+        let details: ProjectDetails | null = null;
+        const prov = getModMarketplaceProvider(mod.source);
+        if (prov) {
+          details = await prov.getProjectDetails(mod.id);
+        }
+        if (details) {
+          selectedModDetails.value = details;
+        } else {
+          // For direct/local mods, create a basic ProjectDetails object
+          selectedModDetails.value = {
+            provider: mod.source as any,
+            projectId: mod.id,
+            slug: mod.projectSlug || mod.id,
+            name: mod.name,
+            summary: 'Локальный мод',
+            iconUrl: mod.image || '',
+            downloads: 0,
+          };
+        }
+      } catch (e) {
+        modDetailsError.value = e instanceof Error ? e.message : String(e);
+        selectedModDetails.value = null;
+      } finally {
+        isLoadingModDetails.value = false;
+      }
+    }
+
+    function clearModDetails() {
+      selectedModDetails.value = null;
+      modDetailsError.value = null;
+    }
+
+    /**
+     * Check for incompatibilities between a mod and installed mods
+     * Uses slug for matching (as per new dependency format)
+     * @param mod - The mod to check
+     * @param installedModsList - Optional list of installed mods to check against (defaults to all installed mods)
+     */
+    function checkIncompatibilities(
+      mod: Mod,
+      installedModsList?: Mod[],
+    ): { conflictingMod: Mod | null } {
+      const installed = installedModsList ?? installedMods.value;
+
+      // Check if mod has incompatible dependencies
+      const incompatibleDeps =
+        mod.dependencies?.filter((d) => d.type === 'incompatible') ?? [];
+
+      for (const dep of incompatibleDeps) {
+        // Find installed mod that matches this incompatible dependency
+        // Match by slug (primary) or fallback to modId for backwards compatibility
+        const conflicting = installed.find((installedMod) => {
+          return (
+            installedMod.projectSlug === dep.slug ||
+            installedMod.id === dep.modId ||
+            // Also check if installed mod's dependencies mark this mod as incompatible
+            installedMod.dependencies?.some(
+              (installedDep) =>
+                installedDep.type === 'incompatible' &&
+                (installedDep.slug === mod.projectSlug ||
+                  installedDep.modId === mod.id),
+            )
+          );
+        });
+
+        if (conflicting) {
+          return { conflictingMod: conflicting };
+        }
+      }
+
+      // Also check if any installed mod marks this mod as incompatible
+      for (const installedMod of installed) {
+        const hasIncompatible = installedMod.dependencies?.some(
+          (dep) =>
+            dep.type === 'incompatible' &&
+            (dep.slug === mod.projectSlug || dep.modId === mod.id),
+        );
+
+        if (hasIncompatible) {
+          return { conflictingMod: installedMod };
+        }
+      }
+
+      return { conflictingMod: null };
+    }
+
+    /**
+     * Resolve all required dependencies for a mod recursively
+     * Uses modId (projectId) for API resolution, slug for checking if already installed
+     */
+    async function resolveDependencies(
+      mod: Mod,
+      installCtx: InstallContext,
+      resolved: Set<string> = new Set(),
+      toInstall: Mod[] = [],
+    ): Promise<Mod[]> {
+      const modKey = `${mod.source}:${mod.id}`;
+      if (resolved.has(modKey)) {
+        return toInstall; // Already resolved
+      }
+      resolved.add(modKey);
+
+      const requiredDeps =
+        mod.dependencies?.filter((d) => d.type === 'required') ?? [];
+
+      for (const dep of requiredDeps) {
+        // Check if dependency is already installed by slug (primary check)
+        const isAlreadyInstalled = installedMods.value.some(
+          (installedMod) =>
+            installedMod.projectSlug === dep.slug ||
+            installedMod.id === dep.modId, // Fallback for backwards compatibility
+        );
+
+        if (isAlreadyInstalled) {
+          continue; // Skip already installed dependencies
+        }
+
+        const depItem = await marketplaceItemForProvider(
+          dep.source,
+          dep.modId,
+          installCtx.projectType,
+        );
+
+        if (!depItem) {
+          console.warn(
+            `[modsEditor] Could not resolve dependency ${dep.modId} (slug: ${dep.slug}) from ${dep.source}`,
+          );
+          continue;
+        }
+
+        const depProv = getModMarketplaceProvider(depItem.provider);
+        if (!depProv) {
+          console.warn(
+            `[modsEditor] No marketplace provider for dependency source ${depItem.provider}`,
+          );
+          continue;
+        }
+
+        const depInstallCtx = withMarketplaceLoaderIdsForProvider(
+          installCtx,
+          depItem.provider,
+        );
+        const depEntry = await depProv.install(depItem, depInstallCtx);
+        const depMod = depEntry as Mod;
+
+        // Recursively resolve dependencies of this dependency
+        await resolveDependencies(depMod, installCtx, resolved, toInstall);
+
+        toInstall.push(depMod);
+      }
+
+      return toInstall;
+    }
+
+    /**
+     * Show incompatibility dialog and wait for user decision
+     */
+    function showIncompatibilityDialog(
+      incompatibleMod: Mod,
+      conflictingMod: Mod,
+    ): Promise<boolean> {
+      return new Promise((resolve) => {
+        incompatibilityDialog.value = {
+          open: true,
+          incompatibleMod,
+          conflictingMod,
+          resolveCallback: resolve,
+        };
+      });
+    }
+
+    function handleIncompatibilityCancel() {
+      if (incompatibilityDialog.value.resolveCallback) {
+        incompatibilityDialog.value.resolveCallback(false);
+      }
+      incompatibilityDialog.value = {
+        open: false,
+        incompatibleMod: null,
+        conflictingMod: null,
+        resolveCallback: null,
+      };
+    }
+
+    function handleIncompatibilityInstallAnyway() {
+      if (incompatibilityDialog.value.resolveCallback) {
+        incompatibilityDialog.value.resolveCallback(true);
+      }
+      incompatibilityDialog.value = {
+        open: false,
+        incompatibleMod: null,
+        conflictingMod: null,
+        resolveCallback: null,
+      };
+    }
+
+    const activeSearchResults = computed(() =>
+      getMarketplaceSearchResults(marketplaceTab.value),
+    );
+
+    function isMarketplaceTabSearching(tabId: string): boolean {
+      syncMarketplaceProviderSearchKeys();
+      if (tabId === 'all') {
+        return listModMarketplaceProviders().some(
+          (p) => isSearchingByProvider[p.id],
+        );
+      }
+      return Boolean(isSearchingByProvider[tabId]);
+    }
+
+    function getMarketplaceSearchResults(tabId: string): MarketplaceItem[] {
+      syncMarketplaceProviderSearchKeys();
+      if (tabId === 'all') {
+        const merged: MarketplaceItem[] = [];
+        for (const p of listModMarketplaceProviders()) {
+          merged.push(...(searchResultsByProvider[p.id] ?? []));
+        }
+        return merged;
+      }
+      return searchResultsByProvider[tabId] ?? [];
+    }
+
+    // Debounced search function (wait 500ms after user stops typing)
+    let debouncedSearch = debounce(() => {
+      void search(true);
+    }, 500);
+
+    // Store watcher stop function
+    let stopWatcher: (() => void) | null = null;
+
+    // Auto-search when query changes (debounced) - will be recreated in init
+    function setupSearchWatcher() {
+      // Stop existing watcher if any
+      if (stopWatcher) {
+        stopWatcher();
+      }
+
+      // Create new watcher
+      stopWatcher = watch(searchQuery, () => {
+        debouncedSearch();
+      });
+    }
+
+    // Initial setup
+    setupSearchWatcher();
+
+    watch(
+      () => [
+        manifest.value?._meta?.manifest?.minecraftVersion,
+        manifest.value?._meta?.manifest?.loader,
+      ] as const,
+      () => {
+        if (!marketplaceBrowseStarted.value) return;
+        void search(true);
+      },
+    );
+
+    /**
+     * Scan for local mods and resource packs
+     */
+    function scanLocalModsAndResourcePacks() {
+      if (!manifest.value?.id) return;
+
+      // Get original manifest from cache (before any edits)
+      const localBuilds = useLocalBuildsModel();
+      const original = localBuilds.getManifestById(manifest.value.id);
+      originalManifest.value = original;
+
+      // Scan local mods
+      localMods.value = scanLocalMods(manifest.value.id, original);
+    }
+
+    /**
+     * Toggle disabled state for a mod
+     */
+    function toggleModDisabledState(mod: Mod, disabled: boolean) {
+      if (!manifest.value?.id) return false;
+
+      // If it's a local mod, toggle the file
+      if (mod.source === 'direct' && mod.id.startsWith('local-')) {
+        const success = toggleModDisabled(manifest.value.id, mod, disabled);
+        if (success) {
+          // Update the mod's disabled state
+          mod.disabled = disabled;
+          // Update file path if needed
+          if (mod.files.length > 0) {
+            const file = mod.files[0];
+            if (disabled) {
+              file.path = file.path.replace(/\.jar$/, '.jar.disabled');
+            } else {
+              file.path = file.path.replace(/\.disabled$/, '');
+            }
+          }
+        }
+        return success;
+      } else {
+        // For manifest mods, update the manifest AND rename the file
+        if (!manifest.value.mods) return false;
+
+        const modIndex = manifest.value.mods.findIndex((m) => m.id === mod.id);
+        if (modIndex >= 0) {
+          // First, rename the file on disk
+          const success = toggleModDisabled(manifest.value.id, mod, disabled);
+          if (!success) return false;
+
+          // Then update the manifest
+          manifest.value.mods[modIndex].disabled = disabled;
+          // Also update file paths
+          for (const file of manifest.value.mods[modIndex].files) {
+            if (disabled) {
+              if (!file.path.endsWith('.disabled')) {
+                file.path = `${file.path}.disabled`;
+              }
+              if (!file.filename.endsWith('.disabled')) {
+                file.filename = `${file.filename}.disabled`;
+              }
+            } else {
+              file.path = file.path.replace(/\.disabled$/, '');
+              file.filename = file.filename.replace(/\.disabled$/, '');
+            }
+          }
+          return true;
+        }
+      }
+      return false;
+    }
+
+    /**
+     * Delete a local mod
+     */
+    function deleteLocalModFile(mod: Mod) {
+      if (!manifest.value?.id) return false;
+
+      if (mod.source === 'direct' && mod.id.startsWith('local-')) {
+        const success = deleteLocalMod(manifest.value.id, mod);
+        if (success) {
+          // Remove from local mods list
+          localMods.value = localMods.value.filter((m) => m.id !== mod.id);
+        }
+        return success;
+      }
+      return false;
+    }
+
+    /**
+     * Инициализация редактора (манифест уже передан при создании store)
+     */
+    const init = async (_manifest: BuildVersionManifest | null) => {
+      console.log('[modsEditor.init] Инициализация:', {
+        hasValue: !!manifest.value,
+        minecraftVersion: manifest.value?._meta?.manifest?.minecraftVersion,
+        loader: manifest.value?._meta?.manifest?.loader,
+        manifest,
+      });
+
+      // Reset search state when reinitializing
+      searchQuery.value = '';
+      searchError.value = null;
+      isSearching.value = false;
+      selectedModDetails.value = null;
+      modDetailsError.value = null;
+      syncMarketplaceProviderSearchKeys();
+      for (const p of listModMarketplaceProviders()) {
+        searchResultsByProvider[p.id] = [];
+        isSearchingByProvider[p.id] = false;
+      }
+
+      const validTabs = new Set<string>([
+        'all',
+        ...listModMarketplaceProviders().map((p) => p.id),
+      ]);
+      if (!validTabs.has(marketplaceTab.value)) {
+        marketplaceTab.value = 'all';
+      }
+
+      // Recreate watcher to ensure it works after reinitialization
+      setupSearchWatcher();
+
+      // Browse marketplace with empty query
+      void search(true);
+
+      // Scan local mods after initialization
+      scanLocalModsAndResourcePacks();
+    };
+
+    return {
+      // Mods editor API
+      projectType,
+      marketplaceTab,
+      searchQuery,
+      isSearching,
+      searchError,
+      activeSearchResults,
+      isMarketplaceTabSearching,
+      getMarketplaceSearchResults,
+      installedMods,
+      installedResourcePacks,
+      allMods,
+      allResourcePacks,
+      localMods,
+      localResourcePacks,
+      isInstalledBySlug,
+      selectedModDetails,
+      isLoadingModDetails,
+      modDetailsError,
+      search,
+      loadMoreMarketplaceResults,
+      canLoadMoreMarketplace,
+      isLoadingMoreMarketplace,
+      marketplaceBrowseStarted,
+      install,
+      removeInstalled,
+      loadModDetails,
+      loadInstalledModDetails,
+      clearModDetails,
+      incompatibilityDialog,
+      handleIncompatibilityCancel,
+      handleIncompatibilityInstallAnyway,
+      dependencyRemovalDialog,
+      handleDependencyRemovalCancel,
+      handleDependencyRemovalOnly,
+      handleDependencyRemovalAll,
+      modsDependencyStatus,
+      dependencyIssuesDialog,
+      openDependencyIssuesDialog,
+      closeDependencyIssuesDialog,
+      resolveIssue,
+      resolveAllIssues,
+      collectAllDependencyIssues,
+      scanLocalModsAndResourcePacks,
+      toggleModDisabledState,
+      deleteLocalModFile,
+      versionSelectionDialog,
+      closeVersionSelectionDialog,
+      confirmVersionSelectionDialog,
+      changeInstalledModVersion,
+      init,
+    };
+  },
+  false,
+);