@antelopejs/interface-core 0.0.2

package/dist/logging/index.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logging = void 0;
+const listener_1 = __importDefault(require("./listener"));
+/**
+ * Provides a structured logging system with multiple severity levels and channels.
+ *
+ * The Logging namespace offers standardized functions for logging at different severity levels
+ * through a unified interface. It supports multiple channels for categorizing logs and
+ * uses an event-based system for log collection and processing.
+ */
+var Logging;
+(function (Logging) {
+    /**
+     * Log severity levels in descending order of importance.
+     * Higher numerical values indicate higher severity.
+     */
+    let Level;
+    (function (Level) {
+        /** Critical errors that may cause application failure */
+        Level[Level["ERROR"] = 40] = "ERROR";
+        /** Important issues that don't prevent application functioning */
+        Level[Level["WARN"] = 30] = "WARN";
+        /** General application information and status updates */
+        Level[Level["INFO"] = 20] = "INFO";
+        /** Detailed information useful for debugging */
+        Level[Level["DEBUG"] = 10] = "DEBUG";
+        /** Highly detailed tracing information */
+        Level[Level["TRACE"] = 0] = "TRACE";
+        /** Messages without prefix for direct display */
+        Level[Level["NO_PREFIX"] = -1] = "NO_PREFIX";
+    })(Level = Logging.Level || (Logging.Level = {}));
+    class Channel {
+        channel;
+        constructor(channel) {
+            this.channel = channel;
+        }
+        /**
+         * Write arguments to the log channel at the ERROR level.
+         *
+         * Use for critical errors that may cause application failure or require immediate attention.
+         *
+         * @param args - Values to log, which can be of any type and will be serialized appropriately
+         */
+        Error(...args) {
+            Write(Level.ERROR, this.channel, ...args);
+        }
+        /**
+         * Write arguments to the log channel at the WARN level.
+         *
+         * Use for important issues that don't prevent the application from functioning
+         * but should be addressed.
+         *
+         * @param args - Values to log, which can be of any type and will be serialized appropriately
+         */
+        Warn(...args) {
+            Write(Level.WARN, this.channel, ...args);
+        }
+        /**
+         * Write arguments to the log channel at the INFO level.
+         *
+         * Use for general application information and status updates that are useful
+         * for understanding the normal operation of the system.
+         *
+         * @param args - Values to log, which can be of any type and will be serialized appropriately
+         */
+        Info(...args) {
+            Write(Level.INFO, this.channel, ...args);
+        }
+        /**
+         * Write arguments to the log channel at the DEBUG level.
+         *
+         * Use for detailed information useful for debugging and troubleshooting issues.
+         *
+         * @param args - Values to log, which can be of any type and will be serialized appropriately
+         */
+        Debug(...args) {
+            Write(Level.DEBUG, this.channel, ...args);
+        }
+        /**
+         * Write arguments to the log channel at the TRACE level.
+         *
+         * Use for highly detailed tracing information, typically only enabled during
+         * intensive debugging sessions.
+         *
+         * @param args - Values to log, which can be of any type and will be serialized appropriately
+         */
+        Trace(...args) {
+            Write(Level.TRACE, this.channel, ...args);
+        }
+        /**
+         * Write arguments to the log channel at the given severity level.
+         *
+         * This is the core logging function that all other logging functions ultimately call.
+         * It emits an event with the log entry that can be captured by registered listeners.
+         *
+         * @param levelId - Severity level of the log entry (use values from the Level enum)
+         * @param args - Values to log, which can be of any type and will be serialized appropriately
+         */
+        Write(levelId, ...args) {
+            Write(levelId, this.channel, ...args);
+        }
+    }
+    Logging.Channel = Channel;
+    const MainChannel = new Channel("main");
+    /**
+     * Write arguments to the main log channel at the ERROR level.
+     *
+     * Use for critical errors that may cause application failure or require immediate attention.
+     *
+     * @param args - Values to log, which can be of any type and will be serialized appropriately
+     */
+    // biome-ignore lint/suspicious/noShadowRestrictedNames: public logging API exposes Error as a level name.
+    Logging.Error = MainChannel.Error.bind(MainChannel);
+    /**
+     * Write arguments to the main log channel at the WARN level.
+     *
+     * Use for important issues that don't prevent the application from functioning
+     * but should be addressed.
+     *
+     * @param args - Values to log, which can be of any type and will be serialized appropriately
+     */
+    Logging.Warn = MainChannel.Warn.bind(MainChannel);
+    /**
+     * Write arguments to the main log channel at the INFO level.
+     *
+     * Use for general application information and status updates that are useful
+     * for understanding the normal operation of the system.
+     *
+     * @param args - Values to log, which can be of any type and will be serialized appropriately
+     */
+    Logging.Info = MainChannel.Info.bind(MainChannel);
+    /**
+     * Write arguments to the main log channel at the DEBUG level.
+     *
+     * Use for detailed information useful for debugging and troubleshooting issues.
+     *
+     * @param args - Values to log, which can be of any type and will be serialized appropriately
+     */
+    Logging.Debug = MainChannel.Debug.bind(MainChannel);
+    /**
+     * Write arguments to the main log channel at the TRACE level.
+     *
+     * Use for highly detailed tracing information, typically only enabled during
+     * intensive debugging sessions.
+     *
+     * @param args - Values to log, which can be of any type and will be serialized appropriately
+     */
+    Logging.Trace = MainChannel.Trace.bind(MainChannel);
+    /**
+     * Write arguments to the specified log channel at the given severity level.
+     *
+     * This is the core logging function that all other logging functions ultimately call.
+     * It emits an event with the log entry that can be captured by registered listeners.
+     *
+     * @param levelId - Severity level of the log entry (use values from the Level enum)
+     * @param channel - Name of the channel to log to, useful for categorizing logs
+     * @param args - Values to log, which can be of any type and will be serialized appropriately
+     */
+    function Write(levelId, channel, ...args) {
+        listener_1.default.emit({
+            time: Date.now(),
+            channel,
+            levelId,
+            args,
+        });
+    }
+    Logging.Write = Write;
+})(Logging || (exports.Logging = Logging = {}));
+exports.default = Logging;
+//# sourceMappingURL=index.js.map

package/dist/logging/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/logging/index.ts"],"names":[],"mappings":";;;;;;AAAA,0DAAkC;AAElC;;;;;;GAMG;AACH,IAAiB,OAAO,CA4KvB;AA5KD,WAAiB,OAAO;IACtB;;;OAGG;IACH,IAAY,KAaX;IAbD,WAAY,KAAK;QACf,yDAAyD;QACzD,oCAAU,CAAA;QACV,kEAAkE;QAClE,kCAAS,CAAA;QACT,yDAAyD;QACzD,kCAAS,CAAA;QACT,gDAAgD;QAChD,oCAAU,CAAA;QACV,0CAA0C;QAC1C,mCAAS,CAAA;QACT,iDAAiD;QACjD,4CAAc,CAAA;IAChB,CAAC,EAbW,KAAK,GAAL,aAAK,KAAL,aAAK,QAahB;IAED,MAAa,OAAO;QACF,OAAO,CAAS;QAEhC,YAAmB,OAAe;YAChC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACzB,CAAC;QAED;;;;;;WAMG;QACI,KAAK,CAAC,GAAG,IAAW;YACzB,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;QAC5C,CAAC;QAED;;;;;;;WAOG;QACI,IAAI,CAAC,GAAG,IAAW;YACxB,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;QAC3C,CAAC;QAED;;;;;;;WAOG;QACI,IAAI,CAAC,GAAG,IAAW;YACxB,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;QAC3C,CAAC;QAED;;;;;;WAMG;QACI,KAAK,CAAC,GAAG,IAAW;YACzB,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;QAC5C,CAAC;QAED;;;;;;;WAOG;QACI,KAAK,CAAC,GAAG,IAAW;YACzB,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;QAC5C,CAAC;QAED;;;;;;;;WAQG;QACI,KAAK,CAAC,OAAe,EAAE,GAAG,IAAW;YAC1C,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;QACxC,CAAC;KACF;IA7EY,eAAO,UA6EnB,CAAA;IAED,MAAM,WAAW,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAExC;;;;;;OAMG;IACH,0GAA0G;IAC7F,aAAK,GAAG,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAEzD;;;;;;;OAOG;IACU,YAAI,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAEvD;;;;;;;OAOG;IACU,YAAI,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAEvD;;;;;;OAMG;IACU,aAAK,GAAG,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAEzD;;;;;;;OAOG;IACU,aAAK,GAAG,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAEzD;;;;;;;;;OASG;IACH,SAAgB,KAAK,CACnB,OAAe,EACf,OAAe,EACf,GAAG,IAAW;QAEd,kBAAQ,CAAC,IAAI,CAAC;YACZ,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE;YAChB,OAAO;YACP,OAAO;YACP,IAAI;SACL,CAAC,CAAC;IACL,CAAC;IAXe,aAAK,QAWpB,CAAA;AACH,CAAC,EA5KgB,OAAO,uBAAP,OAAO,QA4KvB;AACD,kBAAe,OAAO,CAAC"}

package/dist/logging/listener.d.ts

@@ -0,0 +1,26 @@
+import { EventProxy } from "../proxies";
+/**
+ * Represents a structured log entry in the Antelopejs logging system.
+ *
+ * Log entries contain all necessary metadata about a logging event, including
+ * timestamp, severity level, channel, and the actual content being logged.
+ */
+export interface Log {
+    /** Timestamp when the log was created (milliseconds since epoch) */
+    time: number;
+    /** The channel/category this log belongs to (e.g., 'main', 'database', 'network') */
+    channel: string;
+    /** Numeric severity level (higher values indicate higher severity, see Logging.Level enum) */
+    levelId: number;
+    /** The actual content of the log entry, can be any serializable values */
+    args: any[];
+}
+/**
+ * Event proxy for log entry listeners.
+ *
+ * This EventProxy allows parts of the application to subscribe to log events
+ * and process them as needed (e.g., write to console, file, or send to a logging service).
+ * Provides module-aware event handler management with automatic cleanup.
+ */
+declare const _default: EventProxy<(log: Log) => void>;
+export default _default;

package/dist/logging/listener.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const proxies_1 = require("../proxies");
+/**
+ * Event proxy for log entry listeners.
+ *
+ * This EventProxy allows parts of the application to subscribe to log events
+ * and process them as needed (e.g., write to console, file, or send to a logging service).
+ * Provides module-aware event handler management with automatic cleanup.
+ */
+exports.default = new proxies_1.EventProxy();
+//# sourceMappingURL=listener.js.map

package/dist/logging/listener.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"listener.js","sourceRoot":"","sources":["../../src/logging/listener.ts"],"names":[],"mappings":";;AAAA,wCAAwC;AAsBxC;;;;;;GAMG;AACH,kBAAe,IAAI,oBAAU,EAAsB,CAAC"}

package/dist/modules.d.ts

@@ -0,0 +1,165 @@
+import { EventProxy } from ".";
+/**
+ * Contains events related to module lifecycle management.
+ *
+ * These events allow subscribers to be notified when modules change state,
+ * enabling coordinated actions during module transitions.
+ */
+export declare namespace Events {
+    /**
+     * Event triggers when a module is constructed.
+     *
+     * Fires after the module's code has been loaded and a module instance has been created,
+     * but before the module is started.
+     *
+     * @param module Module ID
+     */
+    const ModuleConstructed: EventProxy<(module: string) => void>;
+    /**
+     * Event triggers when a module is started.
+     *
+     * Fires after the module's start method has been called and completed successfully.
+     * At this point, the module is fully operational and available for use.
+     *
+     * @param module Module ID
+     */
+    const ModuleStarted: EventProxy<(module: string) => void>;
+    /**
+     * Event triggers when a module is stopped.
+     *
+     * Fires after the module's stop method has been called and completed successfully.
+     * The module still exists but is no longer active or providing services.
+     *
+     * @param module Module ID
+     */
+    const ModuleStopped: EventProxy<(module: string) => void>;
+    /**
+     * Event triggers when a module is destroyed.
+     *
+     * Fires after the module instance has been destroyed and all its resources
+     * have been released. The module's code may still be loaded, but the instance is gone.
+     *
+     * @param module Module ID
+     */
+    const ModuleDestroyed: EventProxy<(module: string) => void>;
+}
+/**
+ * Configuration for defining a module to be loaded into the system.
+ *
+ * Contains all necessary information to locate, load, and configure a module.
+ */
+export interface ModuleDefinition {
+    /**
+     * Source location and type information for the module.
+     * The type field indicates the loading mechanism to use (e.g., 'file', 'npm').
+     * Additional fields depend on the source type.
+     */
+    source: {
+        type: string;
+    } & Record<string, any>;
+    /**
+     * Optional configuration data passed to the module during initialization.
+     * The structure depends on what the specific module expects.
+     */
+    config?: unknown;
+    /**
+     * Optional mapping of import paths to alternative paths.
+     * Can be used to redirect imports to different modules than requested.
+     */
+    importOverrides?: Record<string, string[]>;
+    /**
+     * Optional list of exports that should not be exposed by this module.
+     * Can be used to restrict what functionality a module provides.
+     */
+    disabledExports?: string[];
+}
+/**
+ * Complete information about a loaded module in the system.
+ *
+ * Extends ModuleDefinition with runtime information about the module's state and location.
+ */
+export type ModuleInfo = Required<ModuleDefinition> & {
+    /**
+     * Current lifecycle status of the module.
+     * - 'loaded': Module code has been loaded but not constructed
+     * - 'constructed': Module instance exists but is not started
+     * - 'active': Module is fully started and running
+     * - 'unknown': Module status cannot be determined
+     */
+    status: "loaded" | "constructed" | "active" | "unknown";
+    /**
+     * File system path where the module is located.
+     */
+    localPath: string;
+};
+/**
+ * List all loaded modules.
+ *
+ * Retrieves the identifiers of all modules currently loaded in the system,
+ * regardless of their status.
+ *
+ * @returns Array of module IDs
+ */
+export declare const ListModules: () => Promise<string[]>;
+/**
+ * Retrieve the configuration and status information of a loaded module.
+ *
+ * Provides comprehensive information about a specific module, including its
+ * configuration, status, and location.
+ *
+ * @param module The module ID to get information for
+ * @returns Complete module information object
+ */
+export declare const GetModuleInfo: (module: string) => Promise<ModuleInfo>;
+/**
+ * Load a new module with the given ID and configuration.
+ *
+ * Loads the module code and optionally constructs and starts the module.
+ * If the module is already loaded, this may update its configuration.
+ *
+ * @param module Unique identifier for the module
+ * @param configuration Module configuration including source information
+ * @param autostart Whether to automatically start the module after loading (default: false)
+ */
+export declare const LoadModule: (module: string, configuration: ModuleDefinition, autostart?: boolean | undefined) => Promise<string[]>;
+/**
+ * Start a loaded but inactive module.
+ *
+ * Transitions a module from 'loaded' or 'constructed' state to 'active'.
+ * Has no effect if the module is already active.
+ *
+ * @param module The module ID to start
+ * @throws Error if the module is not loaded or cannot be started
+ */
+export declare const StartModule: (module: string) => Promise<void>;
+/**
+ * Stop an active module.
+ *
+ * Transitions a module from 'active' state to 'constructed'.
+ * Has no effect if the module is not active.
+ *
+ * @param module The module ID to stop
+ * @throws Error if the module is not loaded or cannot be stopped
+ */
+export declare const StopModule: (module: string) => Promise<void>;
+/**
+ * Destroy a stopped module.
+ *
+ * Releases all resources associated with the module instance.
+ * The module remains loaded but transitions to 'loaded' state from 'constructed'.
+ *
+ * @param module The module ID to destroy
+ * @throws Error if the module is active or not loaded
+ */
+export declare const DestroyModule: (module: string) => Promise<void>;
+/**
+ * Unload a module and retrigger its source mechanism.
+ *
+ * First stops and destroys the module if needed, then unloads the module code
+ * and reloads it from the source. Useful for updating modules without restarting
+ * the entire application.
+ *
+ * @param module The module ID to reload
+ * @throws Error if the module cannot be reloaded
+ */
+export declare const ReloadModule: (module: string) => Promise<void>;

package/dist/modules.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReloadModule = exports.DestroyModule = exports.StopModule = exports.StartModule = exports.LoadModule = exports.GetModuleInfo = exports.ListModules = exports.Events = void 0;
+const _1 = require(".");
+const internal_1 = require("./internal");
+/**
+ * Contains events related to module lifecycle management.
+ *
+ * These events allow subscribers to be notified when modules change state,
+ * enabling coordinated actions during module transitions.
+ */
+var Events;
+(function (Events) {
+    /**
+     * Event triggers when a module is constructed.
+     *
+     * Fires after the module's code has been loaded and a module instance has been created,
+     * but before the module is started.
+     *
+     * @param module Module ID
+     */
+    Events.ModuleConstructed = new _1.EventProxy();
+    /**
+     * Event triggers when a module is started.
+     *
+     * Fires after the module's start method has been called and completed successfully.
+     * At this point, the module is fully operational and available for use.
+     *
+     * @param module Module ID
+     */
+    Events.ModuleStarted = new _1.EventProxy();
+    /**
+     * Event triggers when a module is stopped.
+     *
+     * Fires after the module's stop method has been called and completed successfully.
+     * The module still exists but is no longer active or providing services.
+     *
+     * @param module Module ID
+     */
+    Events.ModuleStopped = new _1.EventProxy();
+    /**
+     * Event triggers when a module is destroyed.
+     *
+     * Fires after the module instance has been destroyed and all its resources
+     * have been released. The module's code may still be loaded, but the instance is gone.
+     *
+     * @param module Module ID
+     */
+    Events.ModuleDestroyed = new _1.EventProxy();
+})(Events || (exports.Events = Events = {}));
+// Using the Events namespace from modules.ts instead of the lowercase events
+Events.ModuleDestroyed.register((module) => {
+    if (internal_1.internal.knownAsync.has(module)) {
+        for (const proxy of internal_1.internal.knownAsync.get(module) ?? []) {
+            proxy.detach();
+        }
+        internal_1.internal.knownAsync.delete(module);
+    }
+    if (internal_1.internal.knownRegisters.has(module)) {
+        for (const proxy of internal_1.internal.knownRegisters.get(module) ?? []) {
+            proxy.detach();
+        }
+        internal_1.internal.knownRegisters.delete(module);
+    }
+    for (const [, proxies] of internal_1.internal.knownRegisters) {
+        for (const proxy of proxies) {
+            proxy.unregisterModule(module);
+        }
+    }
+    for (const proxy of internal_1.internal.knownEvents) {
+        proxy.unregisterModule(module);
+    }
+});
+/**
+ * List all loaded modules.
+ *
+ * Retrieves the identifiers of all modules currently loaded in the system,
+ * regardless of their status.
+ *
+ * @returns Array of module IDs
+ */
+exports.ListModules = (0, _1.InterfaceFunction)();
+/**
+ * Retrieve the configuration and status information of a loaded module.
+ *
+ * Provides comprehensive information about a specific module, including its
+ * configuration, status, and location.
+ *
+ * @param module The module ID to get information for
+ * @returns Complete module information object
+ */
+exports.GetModuleInfo = (0, _1.InterfaceFunction)();
+/**
+ * Load a new module with the given ID and configuration.
+ *
+ * Loads the module code and optionally constructs and starts the module.
+ * If the module is already loaded, this may update its configuration.
+ *
+ * @param module Unique identifier for the module
+ * @param configuration Module configuration including source information
+ * @param autostart Whether to automatically start the module after loading (default: false)
+ */
+exports.LoadModule = (0, _1.InterfaceFunction)();
+/**
+ * Start a loaded but inactive module.
+ *
+ * Transitions a module from 'loaded' or 'constructed' state to 'active'.
+ * Has no effect if the module is already active.
+ *
+ * @param module The module ID to start
+ * @throws Error if the module is not loaded or cannot be started
+ */
+exports.StartModule = (0, _1.InterfaceFunction)();
+/**
+ * Stop an active module.
+ *
+ * Transitions a module from 'active' state to 'constructed'.
+ * Has no effect if the module is not active.
+ *
+ * @param module The module ID to stop
+ * @throws Error if the module is not loaded or cannot be stopped
+ */
+exports.StopModule = (0, _1.InterfaceFunction)();
+/**
+ * Destroy a stopped module.
+ *
+ * Releases all resources associated with the module instance.
+ * The module remains loaded but transitions to 'loaded' state from 'constructed'.
+ *
+ * @param module The module ID to destroy
+ * @throws Error if the module is active or not loaded
+ */
+exports.DestroyModule = (0, _1.InterfaceFunction)();
+/**
+ * Unload a module and retrigger its source mechanism.
+ *
+ * First stops and destroys the module if needed, then unloads the module code
+ * and reloads it from the source. Useful for updating modules without restarting
+ * the entire application.
+ *
+ * @param module The module ID to reload
+ * @throws Error if the module cannot be reloaded
+ */
+exports.ReloadModule = (0, _1.InterfaceFunction)();
+//# sourceMappingURL=modules.js.map

package/dist/modules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.js","sourceRoot":"","sources":["../src/modules.ts"],"names":[],"mappings":";;;AAAA,wBAAkD;AAClD,yCAAsC;AAEtC;;;;;GAKG;AACH,IAAiB,MAAM,CAwCtB;AAxCD,WAAiB,MAAM;IACrB;;;;;;;OAOG;IACU,wBAAiB,GAAG,IAAI,aAAU,EAA4B,CAAC;IAE5E;;;;;;;OAOG;IACU,oBAAa,GAAG,IAAI,aAAU,EAA4B,CAAC;IAExE;;;;;;;OAOG;IACU,oBAAa,GAAG,IAAI,aAAU,EAA4B,CAAC;IAExE;;;;;;;OAOG;IACU,sBAAe,GAAG,IAAI,aAAU,EAA4B,CAAC;AAC5E,CAAC,EAxCgB,MAAM,sBAAN,MAAM,QAwCtB;AAED,6EAA6E;AAC7E,MAAM,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,MAAM,EAAE,EAAE;IACzC,IAAI,mBAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;QACpC,KAAK,MAAM,KAAK,IAAI,mBAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC;YAC1D,KAAK,CAAC,MAAM,EAAE,CAAC;QACjB,CAAC;QACD,mBAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;IACD,IAAI,mBAAQ,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;QACxC,KAAK,MAAM,KAAK,IAAI,mBAAQ,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC;YAC9D,KAAK,CAAC,MAAM,EAAE,CAAC;QACjB,CAAC;QACD,mBAAQ,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACzC,CAAC;IACD,KAAK,MAAM,CAAC,EAAE,OAAO,CAAC,IAAI,mBAAQ,CAAC,cAAc,EAAE,CAAC;QAClD,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC5B,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IACD,KAAK,MAAM,KAAK,IAAI,mBAAQ,CAAC,WAAW,EAAE,CAAC;QACzC,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IACjC,CAAC;AACH,CAAC,CAAC,CAAC;AAuDH;;;;;;;GAOG;AACU,QAAA,WAAW,GAAG,IAAA,oBAAiB,GAAkB,CAAC;AAE/D;;;;;;;;GAQG;AACU,QAAA,aAAa,GACxB,IAAA,oBAAiB,GAAkC,CAAC;AAEtD;;;;;;;;;GASG;AACU,QAAA,UAAU,GACrB,IAAA,oBAAiB,GAMd,CAAC;AAEN;;;;;;;;GAQG;AACU,QAAA,WAAW,GAAG,IAAA,oBAAiB,GAA4B,CAAC;AAEzE;;;;;;;;GAQG;AACU,QAAA,UAAU,GAAG,IAAA,oBAAiB,GAA4B,CAAC;AAExE;;;;;;;;GAQG;AACU,QAAA,aAAa,GAAG,IAAA,oBAAiB,GAA4B,CAAC;AAE3E;;;;;;;;;GASG;AACU,QAAA,YAAY,GAAG,IAAA,oBAAiB,GAA4B,CAAC"}

package/dist/proxies.d.ts

@@ -0,0 +1,135 @@
+type Func<A extends any[] = any[], R = any> = (...args: A) => R;
+/**
+ * Proxy for an asynchronous function.
+ *
+ * Queues up calls while unattached, automatically unattaches when the source module is unloaded.
+ * Provides a mechanism for delayed execution and module-aware function binding.
+ */
+export declare class AsyncProxy<T extends Func = Func, R = Awaited<ReturnType<T>>> {
+    private callback?;
+    private queue;
+    /**
+     * Attaches a callback to the proxy
+     *
+     * Automatically detached if the module calling this function gets unloaded and manualDetach is not set to true.
+     * When attached, any queued calls will be executed immediately.
+     *
+     * @param callback Function to attach
+     * @param manualDetach Don't detach automatically when module is unloaded
+     */
+    onCall(callback: T, manualDetach?: boolean): void;
+    /**
+     * Manually detach the callback on this proxy.
+     */
+    detach(): void;
+    /**
+     * Call the function attached to this proxy.
+     *
+     * If a callback has not been attached yet, the call is queued up for later.
+     */
+    call(...args: Parameters<T>): Promise<R>;
+}
+type RegisterFunction = (id: any, ...args: any[]) => void;
+type RID<T> = T extends (id: infer P, ...args: any[]) => void ? P : never;
+type RArgs<T> = T extends (id: any, ...args: infer P) => void ? P : never;
+/**
+ * Proxy for a pair of register/unregister functions.
+ *
+ * Manages registration of handlers and ensures proper cleanup when modules are unloaded.
+ * This allows for module-aware event registration with automatic cleanup.
+ */
+export declare class RegisteringProxy<T extends RegisterFunction = RegisterFunction> {
+    private registerCallback?;
+    private unregisterCallback?;
+    private registered;
+    /**
+     * Attaches a register callback to the proxy
+     *
+     * Automatically detached if the module calling this function gets unloaded and manualDetach is not set to true.
+     *
+     * @param callback Function to attach as the register callback
+     * @param manualDetach Don't detach automatically
+     */
+    onRegister(callback: T, manualDetach?: boolean): void;
+    /**
+     * Attaches an unregister callback to the proxy
+     *
+     * Detached at the same time as the register callback.
+     *
+     * @param callback Function to attach as the unregister callback
+     */
+    onUnregister(callback: (id: RID<T>) => void): void;
+    /**
+     * Manually detach the callbacks on this proxy.
+     */
+    detach(): void;
+    /**
+     * Call the register callback attached to this proxy.
+     *
+     * If a callback has not been attached yet, the call is queued up for later.
+     *
+     * @param id Unique identifier used to unregister
+     * @param args Extra arguments
+     */
+    register(id: RID<T>, ...args: RArgs<T>): void;
+    /**
+     * Call the unregister callback attached to this proxy.
+     *
+     * @param id Unique identifier to unregister
+     */
+    unregister(id: RID<T>): void;
+    /**
+     * Unregister all entries created by the given module
+     * @internal
+     *
+     * @param mod Module ID
+     */
+    unregisterModule(mod: string): void;
+}
+type EventFunction = (...args: any[]) => void;
+/**
+ * Event handler list that automatically removes handlers from unloaded modules.
+ *
+ * Provides a module-aware event system that cleans up event handlers when modules are unloaded,
+ * preventing memory leaks and ensuring proper modularity.
+ */
+export declare class EventProxy<T extends EventFunction = EventFunction> {
+    private registered;
+    constructor();
+    /**
+     * Call all the event handlers with the specified arguments.
+     *
+     * @param args Arguments
+     */
+    emit(...args: Parameters<T>): void;
+    /**
+     * Register a new handler for this event.
+     *
+     * @param func Handler
+     */
+    register(func: T): void;
+    /**
+     * Unregister a handler on this event.
+     *
+     * @param fn The handler that was passed to {@link register}
+     */
+    unregister(fn: T): void;
+    /**
+     * Unregister all handlers created by the given module.
+     * @internal
+     *
+     * @param mod Module ID
+     */
+    unregisterModule(mod: string): void;
+}
+/**
+ * Gets the responsible module for the current execution context.
+ *
+ * Determines which module is responsible for the current code execution by analyzing the call stack.
+ * This is used for automatic proxy detachment and event handler cleanup.
+ *
+ * @param startFrame The starting frame in the stack trace to analyze
+ * @returns The module ID or undefined if no module is found
+ */
+export declare function GetResponsibleModule(startFrame?: number): string | undefined;
+export {};