fix: more fixes

Author: qubka

content/1.introduction/5.faq.md

@@ -93,7 +93,6 @@ To create a new language module:
 1. Implement the `ILanguageModule` interface provided by Plugify.
 2. Compile the module with the same C++ version and compiler as the Plugify core.
 3. Place the compiled module in the `res/extensions` folder.
-4. Update the `plugify.pconfig` file to include the new module.
 
 Refer to the [Language Module Development Guide](/developer-guide) for detailed instructions.
 ::
@@ -154,7 +153,6 @@ Manifest files are JSON configuration files used by Plugify to define metadata a
          "$schema": "https://raw.githubusercontent.com/untrustedmodders/plugify/refs/heads/main/schemas/config.schema.json",
          "baseDir": "res",
          "logSeverity": "debug",
-         "repositories": [],
          "preferOwnSymbols": false
      }
      ```

content/2.essentials/1.installation.md

@@ -80,13 +80,11 @@ The `plug` app requires a configuration file named `plugify.pconfig` in the work
        "$schema": "https://raw.githubusercontent.com/untrustedmodders/plugify/refs/heads/main/schemas/config.schema.json",
        "baseDir": "res",
        "logSeverity": "debug",
-       "repositories": [],
        "preferOwnSymbols": false
    }
    ```
     - **`baseDir`**: Specifies the directory where plugins and language modules are located (default: `res`).
     - **`logSeverity`**: Controls the logging level (e.g., `debug`, `info`, `error`).
-    - **`repositories`**: A list of remote repositories for downloading packages (leave empty for local testing).
     - **`preferOwnSymbols`**: Determines whether Plugify should prefer its own symbols over those provided by plugins (set to `false` for most use cases).
 
 ### Run the Testing App

content/2.essentials/2.directory-structure.md

@@ -18,11 +18,11 @@ The root directory is where you clone the Plugify repository and build the proje
 
 The `res` directory is the central location for plugins and language modules. It has the following structure:
 
-- **`plugins/`**: Contains individual plugin folders.
+- **`extensions/`**: Contains individual plugin folders.
     - Each plugin folder should include:
         - **`bin/`**: Contains the compiled plugin binaries (e.g., `.dll`, `.so`).
         - **`.pplugin`**: The plugin manifest file (e.g., `my-plugin.pplugin`).
-- **`modules/`**: Contains individual language module folders.
+- **`extensions/`**: Contains individual language module folders.
     - Each language module folder should include:
         - **`bin/`**: Contains the compiled module binaries (e.g., `.dll`, `.so`).
         - **`.pmodule`**: The language module manifest file (e.g., `cpp-module.pmodule`).

content/2.essentials/5.configuration.md

@@ -16,7 +16,6 @@ The `plugify.pconfig` file is required for the `plug` testing app to locate the
     "$schema": "https://raw.githubusercontent.com/untrustedmodders/plugify/refs/heads/main/schemas/config.schema.json",
     "baseDir": "res",
     "logSeverity": "debug",
-    "repositories": [],
     "preferOwnSymbols": false
 }
 ```
@@ -25,7 +24,6 @@ The `plugify.pconfig` file is required for the `plug` testing app to locate the
 #### Configuration Options:
 - **`baseDir`**: Specifies the directory where plugins and language modules are located (default: `res`).
 - **`logSeverity`**: Controls the logging level (e.g., `debug`, `info`, `error`).
-- **`repositories`**: A list of remote repositories for downloading packages (leave empty for local testing).
 - **`preferOwnSymbols`**: Determines whether Plugify should prefer its own symbols over those provided by plugins (set to `false` for most use cases).
 
 ### Plugin Manifest
@@ -94,5 +92,4 @@ The `.pmodule` file defines the configuration for a language module. Below is an
 
 ### Notes:
 - Ensure all configuration files are valid JSON and adhere to the schema provided by Plugify.
-- Use the `$schema` field to validate your configuration files against the official schema.
-- For local testing, leave the `repositories` field in `plugify.pconfig` empty.
+- Use the `$schema` field to validate your configuration files against the official schema.

content/2.essentials/6.commands.md

@@ -18,13 +18,6 @@ Load the plugin manager with plugins and language modules.
 plg load
 ```
 
-**Options**:
-- `--ignore`: Load the plugin manager while ignoring missing or conflicting packages.
-
-  ```bash
-  plg load --ignore
-  ```
-
 ### Unload Plugin Manager
 Unload the plugin manager and all associated plugins and language modules.
 
@@ -78,119 +71,161 @@ Display the current version of Plugify.
 plg version
 ```
 
-## **Package Manager Commands**
+# **Package Manager Commands (mamba)**
 
-Plugify's package manager allows you to install, update, remove, and search for packages. It also supports managing local and remote repositories.
+Mamba is a fast, drop-in replacement for conda and uses the same CLI patterns and configuration. This guide replaces the old Plugify (`plg`) commands with **mamba** equivalents and gives a few practical notes for migrating your workflows. :contentReference[oaicite:0]{index=0}
+
+---
 
 ### Install Packages
-Install one or more packages by name.
+Install one or more packages by name:
 
 ```bash
-plg install _package_name1_ _package_name2_ ...
+mamba install package_name1 package_name2 ...
 ```
 
 **Options**:
-- Install packages from a local manifest file:
+
+- Install packages from a local package list (one package per line):
 
   ```bash
-  plg install --file D:/_package_file_.json
+  mamba install --file /path/to/package_file.txt
   ```
 
-- Install packages from a remote manifest file:
+  *(This accepts the same file-format as `conda install --file` — a simple list of package specs.)*
+
+- Create an environment from an `environment.yml` (recommended for reproducible envs):
 
   ```bash
-  plg install --link https://website.com/_package_file_.json
+  mamba env create -f environment.yml
   ```
 
-- Install missing packages to resolve dependencies:
+  - If your manifest is a remote URL, fetch it then create:
+
+    ```bash
+    curl -sL https://website.com/environment.yml -o environment.yml
+    mamba env create -f environment.yml
+    ```
+
+  *(Using environment YAMLs is the standard way to capture full environment metadata.)* 
+
+- Install packages and let mamba resolve dependencies (default behavior):
 
   ```bash
-  plg install --missing
+  mamba install package_name --yes
   ```
 
+  *(Mamba resolves and installs dependencies automatically; avoid disabling dependency resolution unless you know what you’re doing.)*
+
+---
+
 ### Update Packages
-Update one or more installed packages.
+Update one or more installed packages:
 
 ```bash
-plg update _package_name1_ _package_name2_ ...
+mamba update package_name1 package_name2 ...
 ```
 
 **Options**:
 - Update all installed packages:
 
   ```bash
-  plg update --all
+  mamba update --all
   ```
 
+*(Same command style as conda — `mamba` is a drop-in replacement here.)*
+
+---
+
 ### Remove Packages
-Remove one or more installed packages.
+Remove one or more installed packages:
 
 ```bash
-plg remove _package_name1_ _package_name2_ ...
+mamba remove package_name1 package_name2 ...
 ```
 
 **Options**:
-- Remove all installed packages:
+- Remove all packages in an environment (remove the env):
 
   ```bash
-  plg remove --all
+  mamba env remove -n your_env_name
   ```
 
-- Remove conflicted packages with unresolved dependencies:
+- Force-remove or change dependency behavior only with caution (e.g. `--no-deps`); these flags can break environments.
 
-  ```bash
-  plg remove --conflict
-  ```
+---
 
 ### Search for Packages
 
 #### List Local Packages
-Display all locally installed packages.
+Display all locally installed packages:
 
 ```bash
-plg list
+mamba list
 ```
 
-#### List Remote Packages
-Display all packages available in remote repositories.
+#### List Remote Packages (available in configured channels)
+Show packages available in remote repositories (search across channels):
 
 ```bash
-plg query
+mamba search
 ```
 
-#### Search Remote Packages
-Search for remote packages by name.
+#### Search Remote Packages (by name)
+Search for remote packages by name:
 
 ```bash
-plg search _package_name_
+mamba search package_name
 ```
 
-#### Search Local Packages
-Search for locally installed packages by name.
+#### Show Local Package Info
+Show locally installed package information:
 
 ```bash
-plg show _package_name_
+mamba list package_name
 ```
 
-### Manage Repositories
+*(`mamba search` and `mamba list` mirror conda usage; use `mamba repoquery` for deeper repository dependency queries if you need them.)*
+
+---
 
-#### Add a Repository
-Add a new remote repository for package installation.
+### Manage Repositories / Channels
+
+#### Add a Channel (temporary)
+Use `-c` to specify a channel for a single install:
 
 ```bash
-mamba install -n your_env_name -c https://website.com/conda_channel/ package_name
+mamba install -n your_env_name -c channel_name_or_url package_name
 ```
 
-**Note**: Only add repositories from trusted sources to avoid security risks.
-
-#### Create a Snapshot
-Generate a snapshot of all installed packages into a manifest file. The file will be saved in the base directory.
+#### Add a Channel (permanent)
+Add a remote repository (channel) to your configuration permanently:
 
 ```bash
-plg snapshot
+mamba config --add channels https://website.com/conda_channel/
 ```
 
-## **Best Practices**
-- Always use the `--ignore` flag with caution, as it may lead to unstable behavior if dependencies are missing or conflicted.
-- Regularly update your packages to ensure compatibility and security.
-- Use snapshots to back up your package configurations before making significant changes.
+**Note**: Only add channels from trusted sources. Channel order and priority matter — prefer a pinned channel list (e.g., `conda-forge` then `defaults`) to avoid unexpected package mixes. :contentReference[oaicite:5]{index=5}
+
+---
+
+### Create a Snapshot / Export Environment
+For backups and reproducibility, export the environment in one of two common ways:
+
+- Export a YAML environment spec (cross-platform, recommended):
+
+  ```bash
+  mamba env export -n your_env_name > environment.yml
+  ```
+
+- Create an *explicit* spec file for bit-for-bit reproducibility on the same OS:
+
+  ```bash
+  mamba list --explicit > spec-file.txt
+  # recreate from spec:
+  mamba create --name MY_ENV --file spec-file.txt
+  ```
+
+*(Explicit spec files are single-platform but great for exact restores; YAML is more portable.)*
+
+---

content/3.use-cases/1.metamod-plugin/4.updating.md

@@ -51,7 +51,7 @@ To update plugins and language modules automatically, follow these steps:
    Run the following command to update all installed packages:
 
    ```bash
-   plg update --all
+   mamba update --all
    ```
 
    This will check for updates to plugins and language modules and install them automatically.
@@ -78,12 +78,7 @@ The **package manager cannot update itself or the core Plugify library** at this
    - Verify that you have the correct permissions to modify files in the server directory.
 
 2. **Package Manager Errors**:
-   - If the package manager fails to update, check your internet connection and ensure that the repository URLs in `plugify.pconfig` are correct.
-   - Run the following command to resolve missing or conflicted packages:
-
-     ```bash
-     plg install --missing
-     ```
+   - If the package manager fails to update, check your internet connection and ensure that the repository URLs are correct.
 
 3. **Server Crashes After Update**:
    - Check the server logs for errors related to Plugify or its dependencies.

content/3.use-cases/1.metamod-plugin/5.metamod.md

@@ -20,12 +20,12 @@ Metamod:Source is a plugin loader for Source 2 games like Counter-Strike 2. It p
 #### **Edit `gameinfo.gi`**:
  - Open the `gameinfo.gi` file located in `game/csgo`.
  - Add the following line to the `SearchPaths` section:
-   ```diff
+   ```
    "GameInfo"
    {
-   game 		"Counter-Strike 2"
-   title 		"Counter-Strike 2"
-   title_pw	"E58F8DE68190E7B2BEE88BB1EFBC9AE585A8E79083E694BBE58ABF"
+       game 		"Counter-Strike 2"
+       title 		"Counter-Strike 2"
+       title_pw	"E58F8DE68190E7B2BEE88BB1EFBC9AE585A8E79083E694BBE58ABF"
 
        LayeredOnMod	csgo_imported // Inherits the gameinfo.gi data from csgo_imported (which itself inherits from csgo_core)
 
@@ -35,7 +35,7 @@ Metamod:Source is a plugin loader for Source 2 games like Counter-Strike 2. It p
            {
                Game_LowViolence	csgo_lv // Perfect World content override
 
-     +			Game	csgo/addons/metamod
+                    Game	csgo/addons/metamod // [\!code ++]
                     Game	csgo
                     Game	csgo_imported
                     Game	csgo_core

content/3.use-cases/2.standalone-launcher/4.updating.md

@@ -53,7 +53,7 @@ To update plugins and language modules automatically, follow these steps:
    Run the following command to update all installed packages:
 
    ```bash
-   plg update --all
+   mamba update --all
    ```
 
    This will check for updates to plugins and language modules and install them automatically.
@@ -80,12 +80,7 @@ The **package manager cannot update itself or the core Plugify library** at this
     - Verify that you have the correct permissions to modify files in the game directory.
 
 2. **Package Manager Errors**:
-    - If the package manager fails to update, check your internet connection and ensure that the repository URLs in `plugify.pconfig` are correct.
-    - Run the following command to resolve missing or conflicted packages:
-
-     ```bash
-     plg install --missing
-     ```
+    - If the package manager fails to update, check your internet connection and ensure that the repository URLs are correct.
 
 3. **Game Crashes After Update**:
     - Check the game logs for errors related to Plugify or its dependencies.

content/4.languages/1.python/2.first-plugin.md

@@ -25,9 +25,9 @@ By the end of this tutorial, you’ll have a working Python plugin that can be l
 
 ## Directory Structure
 
-To ensure seamless integration with the Plugify framework, your plugin must follow a specific directory structure. Each plugin should be placed inside its own folder within the `plugins/` directory. The folder name must match the plugin’s name and follow these rules:
+To ensure seamless integration with the Plugify framework, your plugin must follow a specific directory structure. Each plugin should be placed inside its own folder within the `extensions` directory. The folder name must match the plugin’s name and follow these rules:
 
-1. [x] **Allowed Characters**: Alphanumeric (`A-Z, a-z, 0-9`), special characters (`$, #, @, -`).
+1. [x] **Allowed Characters**: Alphanumeric (`A-Z, a-z, 0-9`), special characters (`_`).
 2. [x] **Spaces are NOT allowed** in the folder name.
 3. [x] The `.pplugin` configuration file must have the **same name** as the plugin folder.
 
@@ -160,7 +160,7 @@ These methods are optional. If not implemented, the language module will not cal
 Once you have written your plugin, the next step is to **run and test it** within the Plugify system. To do this, follow these steps:
 
 ### Placing the Plugin in the Correct Directory
-Ensure your plugin is correctly structured inside the `plugins/` folder. Your plugin directory should contain:
+Ensure your plugin is correctly structured inside the `extensions` folder. Your plugin directory should contain:
 
 Once the **plugin folder and manifest file** are correctly placed, Plugify will **automatically detect and attempt to load the plugin**.