@constatic/base 0.0.1-beta.9 → 0.0.1

package/dist/app.js

@@ -1,11 +1,11 @@
 // src/app.ts
-import { version } from "./version.js";
 import { version as djsVersion } from "discord.js";
 import { styleText } from "node:util";
 import { CommandManager } from "./creators/commands/manager.js";
 import { EventManager } from "./creators/events/manager.js";
 import { ResponderManager } from "./creators/responders/manager.js";
 import { baseErrorHandler } from "./error.js";
+import { version } from "./version.js";
 var isBun = typeof Bun !== "undefined";
 
 class ConstaticApp {

package/dist/bootstrap.d.ts

@@ -2,18 +2,67 @@ import { type Client } from "discord.js";
 import { type BaseErrorHandler } from "./app.js";
 import { type CustomClientOptions } from "./client.js";
 export interface BootstrapOptions extends CustomClientOptions {
-    token?: string;
+    /**
+     * The caller module's `import.meta`.
+     * Internally used for resolving file paths when dynamically loading modules.
+     */
     meta: ImportMeta;
+    /**
+     * The Discord bot token.
+     * If omitted, bootstrap will attempt to use:
+     * - `env.BOT_TOKEN`
+     * - `process.env.BOT_TOKEN`
+     */
+    token?: string;
+    /**
+     * A custom error handler that overrides the default one
+     * configured by `ConstaticApp`.
+     *
+     * If provided, all global errors such as:
+     * - `uncaughtException`
+     * - `unhandledRejection`
+     *
+     * will be handled by this function.
+     */
     errorHandler?: BaseErrorHandler;
+    /**
+     * A hook executed before loading the modules.
+     * Can be used to register services, prepare caches,
+     * validate dependencies, or modify the client before initialization.
+     */
     beforeLoad?(client: Client<boolean>): Promise<void>;
+    /**
+     * Additional glob patterns used to load application modules.
+     */
     modules?: string[];
+    /**
+     * Whether initialization logs should be displayed.
+     * Defaults to `true`.
+     */
     loadLogs?: boolean;
+    /**
+     * Custom environment variables that may complement or override
+     * values from `process.env`.
+     */
     env?: Record<string, any>;
 }
+/**
+ *
+ * Bootstraps and initializes a Constatic application, creating the Discord client,
+ * loading modules, registering events, and applying global error handlers.
+ *
+ * @example
+ * import { bootstrap } from "@constatic/base";
+ *
+ * await bootstrap({ meta: import.meta });
+ *
+ * @example
+ * import { env } from "#env";
+ * import { bootstrap } from "@constatic/base";
+ *
+ * await bootstrap({ meta: import.meta, env });
+ */
 export declare function bootstrap(options: BootstrapOptions): Promise<{
     client: Client<boolean>;
-    imports: {
-        module: any;
-        filepath: string;
-    }[];
+    imports: import("./modules.js").ModuleImported[];
 }>;

package/dist/client.d.ts

@@ -1,3 +1,12 @@
 import { Client, type ClientOptions } from "discord.js";
 export type CustomClientOptions = Partial<ClientOptions>;
+/**
+ * Creates and configures a Discord.js client instance integrated with ConstaticApp.
+ *
+ * This function initializes a `Client`, assigns the provided bot token, binds
+ * lifecycle events, and automatically wires command handlers, autocomplete
+ * handlers, and general interaction responders from the Constatic framework.
+ *
+ * The client will log a formatted startup message once it becomes ready.
+ */
 export declare function createClient(token: string, options: CustomClientOptions): Client<boolean>;

package/dist/creators/commands/command.d.ts

@@ -1,9 +1,9 @@
-import { ApplicationCommandOptionType, ApplicationCommandType, AutocompleteInteraction, ChatInputCommandInteraction, MessageContextMenuCommandInteraction, UserContextMenuCommandInteraction, type ApplicationCommandOptionAllowedChannelTypes, type ApplicationCommandOptionChoiceData, type BaseApplicationCommandData, type CacheType, type LocalizationMap } from "discord.js";
+import { ApplicationCommandOptionType, ApplicationCommandType, AutocompleteInteraction, ChatInputCommandInteraction, InteractionContextType, MessageContextMenuCommandInteraction, UserContextMenuCommandInteraction, type ApplicationCommandOptionAllowedChannelTypes, type ApplicationCommandOptionChoiceData, type BaseApplicationCommandData, type CacheType, type LocalizationMap } from "discord.js";
 export type CommandType = Exclude<ApplicationCommandType, ApplicationCommandType.PrimaryEntryPoint>;
 type AutocompleData<Type> = Promise<readonly ApplicationCommandOptionChoiceData<Type extends (number | string) ? Type : (number | string)>[] | undefined | void>;
-export type AutocompleteRun<Type, Perm> = (this: void, interaction: AutocompleteInteraction<CacheMode<Perm>>) => AutocompleData<Type>;
-interface AutocompleteOptionData<Type, Perm> {
-    autocomplete?: true | AutocompleteRun<Type, Perm>;
+export type AutocompleteRun<Type, Contexts> = (this: void, interaction: AutocompleteInteraction<CacheMode<Contexts>>) => AutocompleData<Type>;
+interface AutocompleteOptionData<Type, Contexts> {
+    autocomplete?: true | AutocompleteRun<Type, Contexts>;
 }
 interface BaseOptionData {
     name: string;
@@ -12,13 +12,13 @@ interface BaseOptionData {
     descriptionLocalizations?: LocalizationMap;
     required?: boolean;
 }
-interface StringOptionData<Perm> extends BaseOptionData, AutocompleteOptionData<string, Perm> {
+interface StringOptionData<Contexts> extends BaseOptionData, AutocompleteOptionData<string, Contexts> {
     type: ApplicationCommandOptionType.String;
     choices?: readonly ApplicationCommandOptionChoiceData<string>[];
     minLength?: number;
     maxLength?: number;
 }
-interface NumberOptionData<P> extends BaseOptionData, AutocompleteOptionData<number, P> {
+interface NumberOptionData<Contexts> extends BaseOptionData, AutocompleteOptionData<number, Contexts> {
     type: ApplicationCommandOptionType.Number | ApplicationCommandOptionType.Integer;
     choices?: readonly ApplicationCommandOptionChoiceData<number>[];
     minValue?: number;
@@ -31,16 +31,20 @@ interface ChannelOptionData extends BaseOptionData {
 interface CommonOptionData extends BaseOptionData {
     type: ApplicationCommandOptionType.Attachment | ApplicationCommandOptionType.Boolean | ApplicationCommandOptionType.Mentionable | ApplicationCommandOptionType.Role | ApplicationCommandOptionType.User;
 }
-export type SlashCommandPrimitiveOptionData<Perm> = StringOptionData<Perm> | NumberOptionData<Perm> | CommonOptionData | ChannelOptionData;
-export interface SubCommandOptionData<Perm> extends Omit<BaseOptionData, "required"> {
+export type SlashCommandPrimitiveOptionData<Contexts> = StringOptionData<Contexts> | NumberOptionData<Contexts> | CommonOptionData | ChannelOptionData;
+export interface SubCommandOptionData<Contexts> extends Omit<BaseOptionData, "required"> {
     type: ApplicationCommandOptionType.Subcommand;
-    options?: SlashCommandPrimitiveOptionData<Perm>[];
+    options?: SlashCommandPrimitiveOptionData<Contexts>[];
 }
-export interface GroupOptionData<Perm> extends Omit<BaseOptionData, "required"> {
+export interface GroupOptionData<Contexts> extends Omit<BaseOptionData, "required"> {
     type: ApplicationCommandOptionType.SubcommandGroup;
-    options: SubCommandOptionData<Perm>[];
+    options: SubCommandOptionData<Contexts>[];
 }
-type CacheMode<Perm> = Perm extends false ? "cached" : CacheType;
+type CacheMode<Contexts> = Contexts extends readonly InteractionContextType[] ? {
+    [InteractionContextType.Guild]: "cached";
+    [InteractionContextType.BotDM]: CacheType;
+    [InteractionContextType.PrivateChannel]: CacheType;
+}[Contexts[number]] : CacheType;
 interface CommandRunThis {
     /**
      * Blocks the flow of executions
@@ -48,45 +52,45 @@ interface CommandRunThis {
     block(): never;
 }
 type ResolveCommandModuleData<Return> = Return extends void ? undefined : Return;
-export type SubCommandModuleData<Perm, Return> = Omit<BaseOptionData, "required"> & {
+export type SubCommandModuleData<Contexts, Return> = Omit<BaseOptionData, "required"> & {
     group?: string;
-    run(this: CommandRunThis, interaction: ChatInputCommandInteraction<CacheMode<Perm>>, data: ResolveCommandModuleData<Return>): Promise<void>;
-    options?: SlashCommandPrimitiveOptionData<Perm>[];
+    run(this: CommandRunThis, interaction: ChatInputCommandInteraction<CacheMode<Contexts>>, data: ResolveCommandModuleData<Return>): Promise<void>;
+    options?: SlashCommandPrimitiveOptionData<Contexts>[];
 };
-export type SubCommandGroupModuleData<Perm, Return, T> = Omit<BaseOptionData, "required"> & {
-    options?: Omit<SubCommandOptionData<Perm>, "type">[];
-    run?(this: CommandRunThis, interaction: ChatInputCommandInteraction<CacheMode<Perm>>, data: ResolveCommandModuleData<Return>): Promise<T>;
+export type SubCommandGroupModuleData<Contexts, Return, T> = Omit<BaseOptionData, "required"> & {
+    options?: Omit<SubCommandOptionData<Contexts>, "type">[];
+    run?(this: CommandRunThis, interaction: ChatInputCommandInteraction<CacheMode<Contexts>>, data: ResolveCommandModuleData<Return>): Promise<T>;
 };
-type RunInteraction<T, P> = T extends ApplicationCommandType.Message ? MessageContextMenuCommandInteraction<CacheMode<P>> : T extends ApplicationCommandType.User ? UserContextMenuCommandInteraction<CacheMode<P>> : ChatInputCommandInteraction<CacheMode<P>>;
-type BaseAppCommandData = Omit<BaseApplicationCommandData, "dmPermission"> & Pick<BaseOptionData, "descriptionLocalizations">;
-export interface CommandData<T, P, R> extends BaseAppCommandData {
+type RunInteraction<T, Contexts> = T extends ApplicationCommandType.Message ? MessageContextMenuCommandInteraction<CacheMode<Contexts>> : T extends ApplicationCommandType.User ? UserContextMenuCommandInteraction<CacheMode<Contexts>> : ChatInputCommandInteraction<CacheMode<Contexts>>;
+type BaseAppCommandData = Omit<BaseApplicationCommandData, "contexts"> & Pick<BaseOptionData, "descriptionLocalizations">;
+export interface CommandData<T, Contexts, R> extends BaseAppCommandData {
     name: string;
     description?: string;
-    dmPermission?: P;
+    contexts?: Contexts;
     type?: T;
     global?: boolean;
-    run?(this: CommandRunThis, interaction: RunInteraction<T, P>): Promise<R>;
-    autocomplete?: AutocompleteRun<string | number, P>;
-    options?: SlashCommandPrimitiveOptionData<P>[] | (GroupOptionData<P> | SubCommandOptionData<P>)[];
+    run?(this: CommandRunThis, interaction: RunInteraction<T, Contexts>): Promise<R>;
+    autocomplete?: AutocompleteRun<string | number, Contexts>;
+    options?: SlashCommandPrimitiveOptionData<Contexts>[] | (GroupOptionData<Contexts> | SubCommandOptionData<Contexts>)[];
 }
-export type SlashCommandOptionData<Perm> = SlashCommandPrimitiveOptionData<Perm> | GroupOptionData<Perm> | SubCommandOptionData<Perm>;
+export type SlashCommandOptionData<Contexts> = SlashCommandPrimitiveOptionData<Contexts> | GroupOptionData<Contexts> | SubCommandOptionData<Contexts>;
 export type CommandModule = (SubCommandGroupModuleData<unknown, unknown, unknown> & {
     type: ApplicationCommandOptionType.SubcommandGroup;
 }) | (SubCommandModuleData<unknown, unknown> & {
     type: ApplicationCommandOptionType.Subcommand;
     group?: string;
 });
-declare class GroupCommandModule<Type, Perm, Return, ModuleReturn> {
-    readonly command: Command<Type, Perm, Return>;
-    readonly data: SubCommandGroupModuleData<Perm, Return, ModuleReturn>;
-    constructor(command: Command<Type, Perm, Return>, data: SubCommandGroupModuleData<Perm, Return, ModuleReturn>);
-    subcommand(data: SubCommandModuleData<Perm, ModuleReturn>): this;
+declare class GroupCommandModule<Type, Contexts extends readonly InteractionContextType[], Return, ModuleReturn> {
+    readonly command: Command<Type, Contexts, Return>;
+    readonly data: SubCommandGroupModuleData<Contexts, Return, ModuleReturn>;
+    constructor(command: Command<Type, Contexts, Return>, data: SubCommandGroupModuleData<Contexts, Return, ModuleReturn>);
+    subcommand(data: SubCommandModuleData<Contexts, ModuleReturn>): this;
 }
-export declare class Command<Type, Perm, Return> {
-    readonly data: CommandData<Type, Perm, Return>;
+export declare class Command<Type, Contexts extends readonly InteractionContextType[], Return> {
+    readonly data: CommandData<Type, Contexts, Return>;
     readonly modules: CommandModule[];
-    constructor(data: CommandData<Type, Perm, Return>);
-    group<ModuleReturn>(data: SubCommandGroupModuleData<Perm, Return, ModuleReturn>): GroupCommandModule<Type, Perm, Return, ModuleReturn>;
-    subcommand<R = Return>(data: SubCommandModuleData<Perm, R>): this;
+    constructor(data: CommandData<Type, Contexts, Return>);
+    group<ModuleReturn = Return>(data: SubCommandGroupModuleData<Contexts, Return, ModuleReturn>): GroupCommandModule<Type, Contexts, Return, ModuleReturn>;
+    subcommand<R = Return>(data: SubCommandModuleData<Contexts, R>): this;
 }
 export {};

package/dist/creators/commands/command.js

@@ -1,5 +1,5 @@
 // src/creators/commands/command.ts
-import { ApplicationCommandOptionType, ApplicationCommandType } from "discord.js";
+import { ApplicationCommandOptionType, ApplicationCommandType, InteractionContextType } from "discord.js";
 
 class GroupCommandModule {
   command;
@@ -21,7 +21,6 @@ class Command {
   constructor(data) {
     this.data = data;
     this.data.type ??= ApplicationCommandType.ChatInput;
-    this.data.dmPermission ??= false;
     if (this.data.type === ApplicationCommandType.ChatInput) {
       this.data.description ??= this.data.name;
       this.data.name = this.data.name.toLowerCase().replaceAll(" ", "");
@@ -29,6 +28,11 @@ class Command {
     if (this.data.name.length > 32) {
       this.data.name = this.data.name.slice(0, 32);
     }
+    if (!this.data.contexts) {
+      Object.assign(this.data, {
+        contexts: [InteractionContextType.Guild]
+      });
+    }
   }
   group(data) {
     this.modules.push({

package/dist/creators/commands/manager.d.ts

@@ -1,4 +1,4 @@
-import { ApplicationCommandType, AutocompleteInteraction, Client, CommandInteraction, type ChatInputApplicationCommandData, type MessageApplicationCommandData, type UserApplicationCommandData } from "discord.js";
+import { ApplicationCommandType, AutocompleteInteraction, Client, CommandInteraction, InteractionContextType, type ChatInputApplicationCommandData, type MessageApplicationCommandData, type UserApplicationCommandData } from "discord.js";
 import { BaseManager } from "../manager.js";
 import type { Command, CommandType } from "./command.js";
 type Runner = Function | null | undefined;
@@ -9,7 +9,7 @@ export declare class CommandManager extends BaseManager {
     private get config();
     private readonly collection;
     readonly runners: Map<string, Runner[]>;
-    set<T, P, R>(command: Command<T, P, R>): void;
+    set<T, C extends readonly InteractionContextType[], R>(command: Command<T, C, R>): void;
     getTitle(type?: CommandType): string[];
     build(): BuildedCommandData[];
     private buildOptions;

package/dist/creators/events/manager.d.ts

@@ -1,9 +1,9 @@
-import { Client, Collection } from "discord.js";
+import { Client, Collection, type ClientEvents } from "discord.js";
 import { BaseManager } from "../manager.js";
 import type { ClientEventKey, Event, EventsCollection, GenericEventArgs } from "./event.js";
 export declare class EventManager extends BaseManager {
     private get config();
-    readonly collection: Collection<keyof import("discord.js").ClientEvents, EventsCollection>;
+    readonly collection: Collection<keyof ClientEvents, EventsCollection>;
     getEvents(key: ClientEventKey): EventsCollection;
     add(event: Event<ClientEventKey>): void;
     onEvent(event: Event<ClientEventKey>, args: GenericEventArgs): Promise<void>;

package/dist/creators/setup.d.ts

@@ -1,4 +1,4 @@
-import type { ApplicationCommandType, CacheType, ClientEvents, PermissionResolvable } from "discord.js";
+import { ApplicationCommandType, InteractionContextType, type CacheType, type ClientEvents, type PermissionResolvable } from "discord.js";
 import { type BaseCommandsConfig, type BaseEventsConfig, type BaseRespondersConfig } from "../app.js";
 import { Command, type CommandData, type CommandType } from "./commands/command.js";
 import { Event, type EventData } from "./events/event.js";
@@ -10,8 +10,31 @@ export interface SetupCreatorsOptions {
     responders?: Partial<BaseRespondersConfig>;
     events?: Partial<BaseEventsConfig>;
 }
+/**
+ * Initializes the Constatic command/event/responder creation system.
+ *
+ * This function configures the Constatic application’s internal registries
+ * for commands, events, and responders, and returns a set of factory
+ * functions used to create each type of component.
+ *
+ * It also:
+ * - Applies optional default command permissions
+ * - Merges user-provided config into the ConstaticApp instance
+ * - Automatically injects `process.env.GUILD_ID` into guild-restricted commands
+ * - Ensures `"clientReady"` events always run once
+ *
+ * **Returned creators:**
+ * - `createCommand(data)` — Registers a new slash command (or other command type)
+ * - `createEvent(data)` — Registers a Discord.js event listener
+ * - `createResponder(data)` — Registers an interaction responder (buttons, modals, etc.)
+ *
+ * @example
+ * import { setupCreators } from "@constatic/base";
+ *
+ * export const { createCommand, createResponder, createEvent } = setupCreators();
+ */
 export declare function setupCreators(options?: SetupCreatorsOptions): {
-    createCommand<T extends CommandType = ApplicationCommandType.ChatInput, P extends boolean = false, R = void>(data: CommandData<T, P, R>): Command<T, P, R>;
+    createCommand: <T extends CommandType = ApplicationCommandType.ChatInput, const C extends readonly InteractionContextType[] = [InteractionContextType.Guild], R = void>(data: CommandData<T, C, R>) => Command<T, C, R>;
     createEvent: <EventName extends keyof ClientEvents>(data: EventData<EventName>) => Event<EventName>;
-    createResponder<Path extends string, const Types extends readonly ResponderType[], Parsed, Cache extends CacheType = CacheType>(data: ResponderData<Path, Types, Parsed, Cache>): Responder<Path, Types, Parsed, Cache>;
+    createResponder: <Path extends string, const Types extends readonly ResponderType[], Parsed, Cache extends CacheType = CacheType>(data: ResponderData<Path, Types, Parsed, Cache>) => Responder<Path, Types, Parsed, Cache>;
 };

package/dist/creators/setup.js

@@ -13,7 +13,7 @@ function setupCreators(options = {}) {
     app.config.commands.guilds.push(process.env.GUILD_ID);
   }
   return {
-    createCommand(data) {
+    createCommand: function(data) {
       if (options.commands?.defaultMemberPermissions) {
         data.defaultMemberPermissions ??= options.commands.defaultMemberPermissions;
       }
@@ -29,7 +29,7 @@ function setupCreators(options = {}) {
       app.events.add(event);
       return event;
     },
-    createResponder(data) {
+    createResponder: function(data) {
       const responder = new Responder(data);
       app.responders.set(responder);
       return responder;

package/dist/env.d.ts

@@ -1,5 +1,28 @@
 import type { StandardSchemaV1 } from "./utils/schema.js";
 type Schema = StandardSchemaV1;
 type Out<T extends Schema> = StandardSchemaV1.InferOutput<T>;
+/**
+ * Validates the current process environment variables using a StandardSchema.
+ *
+ * This function executes the schema validation against `process.env`
+ * and ensures all required environment variables follow the expected shape.
+ * @example
+ * // "env.ts" — Using Zod
+ * import { z } from "zod";
+ * import { validateEnv } from "@constatic/base";
+ *
+ * export const env = await validateEnv(z.object({
+ *     BOT_TOKEN: z.string("BOT_TOKEN is required").min(1)
+ * }).passthrough());
+ *
+ * @example
+ * // "env.ts" — Using ArkType
+ * import { type } from "arktype";
+ * import { validateEnv } from "@constatic/base";
+ *
+ * export const env = await validateEnv(type({
+ *     BOT_TOKEN: "string > 0"
+ * }));
+ */
 export declare function validateEnv<T extends Schema>(schema: T): Promise<Out<T>>;
 export {};

package/dist/error.js

@@ -1,5 +1,5 @@
 // src/error.ts
-import { codeBlock, TextDisplayBuilder, time, WebhookClient } from "discord.js";
+import { codeBlock, TextDisplayBuilder, time, parseWebhookURL, REST, Routes } from "discord.js";
 import console from "node:console";
 import { styleText } from "node:util";
 
@@ -31,24 +31,31 @@ async function baseErrorHandler(error, client) {
   const url = process.env.WEBHOOK_LOGS_URL;
   if (!url)
     return;
+  const data = parseWebhookURL(url);
+  if (!data)
+    return;
+  const rest = new REST;
+  if (process.env.BOT_TOKEN)
+    rest.setToken(process.env.BOT_TOKEN);
   try {
-    const webhook = new WebhookClient({ url });
     const username = client?.user?.username;
-    await webhook.send({
-      flags: ["IsComponentsV2"],
-      components: [
-        new TextDisplayBuilder({
-          content: [
-            codeBlock("ansi", text.join(`
+    rest.post(Routes.webhook(data.id, data.token), {
+      body: {
+        flags: ["IsComponentsV2"],
+        components: [
+          new TextDisplayBuilder({
+            content: [
+              codeBlock("ansi", text.join(`
 `)),
-            time(new Date, "R")
-          ].join(`
+              time(new Date, "R")
+            ].join(`
 `)
-        })
-      ],
-      withComponents: true,
-      avatarURL: client?.user?.displayAvatarURL({ size: 512 }),
-      username: username ? `${username} logs` : "Logs"
+          })
+        ],
+        withComponents: true,
+        avatarURL: client?.user?.displayAvatarURL({ size: 512 }),
+        username: username ? `${username} logs` : "Logs"
+      }
     }).catch(console.error);
   } catch {
     console.log();

package/dist/modules.d.ts

@@ -1,4 +1,9 @@
-export declare function loadModules(meta: ImportMeta, modules?: string[]): Promise<{
+export interface ModuleImported {
     module: any;
     filepath: string;
-}[]>;
+}
+/**
+ * Dynamically loads modules using glob patterns, returning each imported module
+ * along with its file path.
+ */
+export declare function loadModules(meta: ImportMeta, modules?: string[]): Promise<ModuleImported[]>;

package/dist/modules.js

@@ -1,14 +1,17 @@
 // src/modules.ts
-import { glob } from "node:fs/promises";
-import path from "node:path";
+import { join } from "node:path";
+import { glob } from "tinyglobby";
 async function loadModules(meta, modules = []) {
-  const exclude = modules.filter((path2) => path2.charAt(0) == "!").map((path2) => path2.slice(1));
-  const filepaths = await Array.fromAsync(glob(modules, { cwd: meta.dirname, exclude }));
-  const promises = filepaths.map((filepath) => import(path.join(meta.dirname, filepath)).then((imported) => ({
-    module: imported,
-    filepath
-  })));
-  return Promise.all(promises);
+  const ignore = modules.filter((path) => path.charAt(0) == "!").map((path) => path.slice(1));
+  const filepaths = await glob(modules, { cwd: meta.dirname, ignore });
+  const loadModules2 = [];
+  for (const path of filepaths) {
+    await import(join(meta.dirname, path)).then((imported) => loadModules2.push({
+      module: imported,
+      filepath: path
+    }));
+  }
+  return loadModules2;
 }
 export {
   loadModules

package/dist/version.d.ts

@@ -1 +1,7 @@
+/**
+ * Represents the current lib version.
+ *
+ * The version follows semantic versioning (SemVer), typically in the format:
+ * `"MAJOR.MINOR.PATCH"` — for example: `"1.0.0"`.
+ */
 export declare const version: string;

package/dist/version.js

@@ -1,5 +1,5 @@
 // src/version.ts
-var version = "0.0.1-beta.9";
+var version = "1.0.0";
 export {
   version
 };

package/package.json

@@ -1,12 +1,36 @@
 {
   "name": "@constatic/base",
-  "version": "0.0.1-beta.9",
-  "description": "",
+  "version": "0.0.1",
+  "description": "Library with structures and functions for creating modern Discord applications.",
   "license": "MIT",
   "type": "module",
   "publishConfig": {
     "access": "public"
   },
+  "keywords": [
+    "modern",
+    "base",
+    "discord",
+    "bot",
+    "discord bot",
+    "discord app",
+    "discord application",
+    "discord api",
+    "discord.js",
+    "typescript",
+    "app",
+    "api",
+    "tools",
+    "router",
+    "handlers",
+    "managers",
+    "loaders",
+    "modules",
+    "development",
+    "es6",
+    "node",
+    "bun"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/rinckodev/constatic",
@@ -18,8 +42,7 @@
   },
   "devDependencies": {
     "@constatic/config": "*",
-    "@standard-schema/spec": "^1.0.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.8.2"
   },
   "exports": {
     ".": {
@@ -39,16 +62,17 @@
     ]
   },
   "scripts": {
+    "check": "tsc --noEmit",
     "typegen": "tsc",
     "build": "bun run ./build.ts",
     "prepublish": "bun run build",
     "dev": "bun run ./playground/index.ts"
   },
   "peerDependencies": {
-    "discord.js": "^14.24.2"
+    "discord.js": "^14.25.1"
   },
   "dependencies": {
-    "@discordjs/core": "^2.3.0",
-    "rou3": "^0.7.10"
+    "rou3": "^0.7.12",
+    "tinyglobby": "^0.2.15"
   }
 }