Hoshimi (BETA)

import { Hoshimi } from "hoshimi"; // She is all ears!
import { Client } from "seyfert"; // Only example client, you can use whatever you want...

const client = new Client(); // https://www.seyfert.dev/guide

const hoshimi = new Hoshimi({
    nodes: [
        {
            host: "localhost",
            port: 2333,
            password: "youshallnotpass",
        },
    ], // Add more nodes if you want!
    sendPayload(guildId, payload) {
        // Your client send to shard payload function
        client.gateway.send(client.gateway.calculateShardId(guildId), payload);
    },
});

// Bind the manager into your client!
client.hoshimi = hoshimi;

// FOLLOW YOUR CLIENT EVENT IMPLEMENTATION
// THIS IS ONLY A EXAMPLE, NOT A REAL USAGE
client.events.values.READY = {
    __filePath: null,
    data: { name: "ready", once: true },
    run(user, client) {
        client.logger.info(`Logged in as ${user.username}`);
        
        // Call the manager to initialize hoshimi
        hoshimi.init({ ...user, username: user.username });
    },
};

client.events.values.RAW = {
    __filePath: null,
    data: { name: "raw" },
    async run(data, client) {
        // Call the handler on the gateway dispatch events
        await hoshimi.updateVoiceState(data);
    },
};

(async () => {
    await client.start();
})();

import { DebugLevels, EventNames } from "hoshimi";

hoshimi.on(EventNames.NodeReady, (node) => {
    console.log(`Node ${node.id} is ready.`);
});

hoshimi.on(EventNames.TrackStart, (player, track) => {
    console.log(`Now playing "${track?.info.title}" in ${player.guildId}`);
    // `player.textId` is the channel the player was created with, if you set one.
});

hoshimi.on(EventNames.QueueEnd, async (player) => {
    console.log(`Nothing left to play in ${player.guildId}`);
    await player.destroy();
});

hoshimi.on(EventNames.PlayerDestroy, (player, reason) => {
    console.log(`Player for ${player.guildId} destroyed: ${reason}`);
});

hoshimi.on(EventNames.NodeError, (node, error) => console.error(`Node ${node.id} failed:`, error));
hoshimi.on(EventNames.Error, (error) => console.error(error));

hoshimi.on(EventNames.Debug, (level, message) => {
    if (level === DebugLevels.Player) console.debug(message);
});

import { FilterType } from "hoshimi";

const player = hoshimi.getPlayer("guildId");

await player.filterManager.setNightcore();
await player.filterManager.set(FilterType.Echo, { delay: 200, decay: 0.5 });

player.filterManager.isEnabled(FilterType.Echo); // true
player.filterManager.getEnabled();               // ["timescale", "echo"]
player.filterManager.get(FilterType.Timescale);  // TimescaleSettings | undefined

await player.filterManager.clear(FilterType.Echo);
await player.filterManager.reset();              // drops every filter

// pluginFilters.myFilter — the extension point the Lavalink v4 spec defines
await player.filterManager.set("myFilter", { gain: 2 });

// pluginFilters["my-plugin"].boost — nested, per the spec's plugin shape
await player.filterManager.set("boost", { gain: 2 }, { plugin: "my-plugin" });

// filters.forkEcho — top level, next to the built-ins, where forks expose theirs
await player.filterManager.set("forkEcho", { decay: 0.5 }, { top: true });

// Clear it from the same envelope it was written to
await player.filterManager.clear("boost", { plugin: "my-plugin" });

import { FilterRegistry, FilterScope, PluginCapabilities } from "hoshimi";

FilterRegistry.register({
    name: "boost",
    scope: FilterScope.Plugin,      // Plugin -> pluginFilters · Core -> top level
    pluginName: "my-plugin",        // omit to write it flat under pluginFilters
    capability: PluginCapabilities.Filters,
});

await player.filterManager.set("boost", { gain: 2 }); // routed and validated

declare module "hoshimi" {
    interface CustomizableFilters {
        forkEcho: { decay: number; delay: number };
    }
}

await player.filterManager.set("forkEcho", { decay: 0.5, delay: 200 }, { top: true });
player.filterManager.get("forkEcho", { top: true }); // { decay: number; delay: number } | undefined