@mxweb/core 1.0.0

package/dist/common.d.ts

@@ -0,0 +1,323 @@
+/**
+ * @fileoverview Common types, interfaces, and utilities used throughout the @mxweb/core framework.
+ * This module provides foundational types for dependency injection, routing, and lifecycle management.
+ * @module common
+ */
+/**
+ * Interface for Application-level dependency injects.
+ * All global injects must implement this interface to ensure consistent lifecycle management.
+ *
+ * @remarks
+ * Application injects are singleton instances that persist across all requests.
+ * They are initialized once when the first request arrives and destroyed when the application shuts down.
+ *
+ * @example
+ * ```ts
+ * class DatabaseConnection implements ApplicationInject {
+ *   private connection: Connection;
+ *
+ *   async onInit() {
+ *     this.connection = await createConnection();
+ *     console.log("Database connected");
+ *   }
+ *
+ *   async onDestroy() {
+ *     await this.connection.close();
+ *     console.log("Database disconnected");
+ *   }
+ * }
+ * ```
+ */
+export interface ApplicationInject {
+    /**
+     * Called when the inject is initialized (on first request).
+     * Use this to establish connections, load resources, or perform async setup.
+     */
+    onInit?(): void | Promise<void>;
+    /**
+     * Called when the application is shutting down (SIGTERM/SIGINT).
+     * Use this to clean up resources, close connections, or flush buffers.
+     */
+    onDestroy?(): void | Promise<void>;
+}
+/**
+ * Interface for Feature-specific dependency injects.
+ * Use this for injects that are scoped to a specific feature/module.
+ *
+ * @remarks
+ * Feature injects are local to a feature and can have different instances per feature.
+ * They are loaded when the feature is first accessed and destroyed on application shutdown.
+ *
+ * @example
+ * ```ts
+ * class ProductRepository implements FeatureInject {
+ *   async onFeature() {
+ *     console.log("ProductRepository initialized for this feature");
+ *   }
+ *
+ *   async onFeatureDestroy() {
+ *     console.log("ProductRepository destroyed");
+ *   }
+ * }
+ * ```
+ */
+export interface FeatureInject {
+    /**
+     * Called when the feature is loaded.
+     * Use this for feature-specific initialization.
+     */
+    onFeature?(): void | Promise<void>;
+    /**
+     * Called when the feature is destroyed/shutdown.
+     * Use this for feature-specific cleanup.
+     */
+    onFeatureDestroy?(): void | Promise<void>;
+}
+/**
+ * Utility type for values that can be either synchronous or async.
+ * Commonly used for configuration that may need async resolution.
+ *
+ * @template Result - The type of the resolved value
+ * @template Arg - The argument type passed to the function (defaults to void)
+ *
+ * @example
+ * ```ts
+ * // Can be used as a plain value
+ * const config: AsyncFn<Config> = { port: 3000 };
+ *
+ * // Or as an async resolver
+ * const config: AsyncFn<Config> = async () => {
+ *   return await loadConfigFromEnv();
+ * };
+ * ```
+ */
+export type AsyncFn<Result, Arg = void> = Result | ((arg: Arg) => Promise<Result>);
+/**
+ * Payload structure for Next.js catch-all routes.
+ * Contains the promise of route parameters extracted from the URL path.
+ *
+ * @template Key - The key name used in the catch-all route (defaults to "path")
+ *
+ * @example
+ * ```ts
+ * // For route: app/api/[[...path]]/route.ts
+ * // URL: /api/products/123
+ * // payload.params resolves to { path: ["products", "123"] }
+ * ```
+ */
+export interface RoutePayload<Key extends string = "path"> {
+    /** Promise containing the parsed path segments */
+    params: Promise<{
+        [K in Key]?: string[];
+    }>;
+}
+/**
+ * Function type for middleware next() callback.
+ * Call this function to continue to the next middleware in the chain.
+ */
+export type RouteNextHandler = () => void;
+/**
+ * Function type for call handlers used in interceptors.
+ * Returns a promise of the handler result.
+ *
+ * @template T - The type of the resolved value
+ */
+export type CallHandler<T = unknown> = () => Promise<T>;
+/**
+ * Interface for pipe transformers.
+ * Pipes are used to transform input data before it reaches the handler.
+ *
+ * @template Input - The type of input value
+ * @template Output - The type of transformed output value
+ *
+ * @example
+ * ```ts
+ * class ValidationPipe implements PipeTransform<unknown, ValidatedDto> {
+ *   transform(value: unknown): ValidatedDto {
+ *     // Validate and transform the input
+ *     return validateAndTransform(value);
+ *   }
+ * }
+ * ```
+ */
+export interface PipeTransform<Input = unknown, Output = unknown> {
+    /**
+     * Transforms the input value to the output value.
+     *
+     * @param value - The input value to transform
+     * @returns The transformed value (can be async)
+     */
+    transform(value: Input): Output | Promise<Output>;
+}
+/**
+ * Constructor type for Pipe classes.
+ *
+ * @template Input - The type of input value the pipe accepts
+ * @template Output - The type of output value the pipe produces
+ */
+export type Pipe<Input = unknown, Output = unknown> = new (...args: unknown[]) => PipeTransform<Input, Output>;
+/**
+ * Constructor type for inject classes.
+ * Used when registering injects that need to be instantiated.
+ *
+ * @template T - The type of the inject instance (must implement ApplicationInject)
+ */
+export type InjectClass<T extends ApplicationInject = ApplicationInject> = new (...args: unknown[]) => T;
+/**
+ * Generic class constructor type.
+ *
+ * @template T - The type of instance the constructor creates
+ * @template Injects - Tuple type of constructor arguments
+ */
+export interface ClassContructor<T, Injects extends any[] = []> {
+    new (...args: Injects): T;
+}
+/**
+ * Interface for injectable classes with singleton and factory methods.
+ * Classes implementing this interface can be registered in the InjectionRegistry.
+ *
+ * @template T - The type of instance the class creates
+ * @template Args - Tuple type of constructor/factory arguments
+ *
+ * @example
+ * ```ts
+ * class UserService implements InjectedClass<UserService> {
+ *   static readonly injectionName = "userService";
+ *
+ *   private static instance: UserService | null = null;
+ *
+ *   static singleton(): UserService {
+ *     if (!this.instance) {
+ *       this.instance = new UserService();
+ *     }
+ *     return this.instance;
+ *   }
+ *
+ *   static get(): UserService {
+ *     return new UserService();
+ *   }
+ * }
+ * ```
+ */
+export interface InjectedClass<T, Args extends any[] = []> extends ClassContructor<T, Args> {
+    /**
+     * Factory method to get a new instance.
+     * @param args - Arguments to pass to the constructor
+     * @returns A new instance or null if creation fails
+     */
+    get(...args: Args): T | null;
+    /**
+     * Factory method to get a singleton instance.
+     * @param args - Arguments to pass to the constructor (only used on first call)
+     * @returns The singleton instance or null if creation fails
+     */
+    singleton(...args: Args): T | null;
+    /** Unique name for this injectable class */
+    readonly injectionName: string;
+}
+/**
+ * Global registry for injectable classes and their singleton instances.
+ * Provides static methods to register, retrieve, and manage injectable dependencies.
+ *
+ * @remarks
+ * This registry acts as a simple IoC container for managing class constructors
+ * and their singleton instances across the application.
+ *
+ * @example
+ * ```ts
+ * // Register an injectable class
+ * InjectionRegistry.registry("userService", UserService);
+ *
+ * // Retrieve and use
+ * const UserServiceClass = InjectionRegistry.get("userService");
+ * const instance = UserServiceClass?.singleton();
+ *
+ * // Store singleton instance
+ * InjectionRegistry.setInstance("userService", instance);
+ * ```
+ */
+export declare class InjectionRegistry {
+    /** Map of registered class constructors by name */
+    private static constructors;
+    /** Map of singleton instances by name */
+    private static instances;
+    /**
+     * Registers an injectable class constructor with a given name.
+     *
+     * @template T - The type of instance the class creates
+     * @template Args - Tuple type of constructor arguments
+     * @param name - Unique name to register the class under
+     * @param Contructor - The injectable class constructor
+     */
+    static registry<T, Args extends any[] = []>(name: string, Contructor: InjectedClass<T, Args>): void;
+    /**
+     * Returns a copy of all registered class constructors.
+     *
+     * @returns A new Map containing all registered name-constructor pairs
+     */
+    static getAll(): Map<string, InjectedClass<any, any[]>>;
+    /**
+     * Retrieves a registered class constructor by name.
+     *
+     * @template T - The type of instance the class creates
+     * @template Args - Tuple type of constructor arguments
+     * @param name - The name the class was registered under
+     * @returns The class constructor or null if not found
+     */
+    static get<T, Args extends any[] = []>(name: string): InjectedClass<T, Args> | null;
+    /**
+     * Checks if a class constructor is registered under the given name.
+     *
+     * @param name - The name to check
+     * @returns true if a constructor is registered, false otherwise
+     */
+    static has(name: string): boolean;
+    /**
+     * Returns an array of all registered injection names.
+     *
+     * @returns Array of registered names
+     */
+    static names(): string[];
+    /**
+     * Stores a singleton instance by name.
+     *
+     * @param name - The name to store the instance under
+     * @param instance - The instance to store
+     */
+    static setInstance(name: string, instance: unknown): void;
+    /**
+     * Retrieves a stored singleton instance by name.
+     *
+     * @template T - The expected type of the instance
+     * @param name - The name the instance was stored under
+     * @returns The instance or undefined if not found
+     */
+    static getInstance<T>(name: string): T | undefined;
+    /**
+     * Checks if a singleton instance exists for the given name.
+     *
+     * @param name - The name to check
+     * @returns true if an instance exists, false otherwise
+     */
+    static hasInstance(name: string): boolean;
+}
+/**
+ * Enumeration of supported HTTP methods.
+ * Used throughout the framework for route matching and handler creation.
+ */
+export declare enum RouteMethod {
+    /** HTTP GET method - retrieve resources */
+    GET = "GET",
+    /** HTTP POST method - create resources */
+    POST = "POST",
+    /** HTTP PUT method - replace resources */
+    PUT = "PUT",
+    /** HTTP PATCH method - partial update resources */
+    PATCH = "PATCH",
+    /** HTTP DELETE method - remove resources */
+    DELETE = "DELETE",
+    /** HTTP HEAD method - retrieve headers only */
+    HEAD = "HEAD",
+    /** HTTP OPTIONS method - CORS preflight requests */
+    OPTIONS = "OPTIONS"
+}

package/dist/common.js

@@ -0,0 +1 @@
+"use strict";class t{static registry(t,s){this.constructors.set(t,s)}static getAll(){return new Map(this.constructors)}static get(t){return this.constructors.get(t)||null}static has(t){return this.constructors.has(t)}static names(){return Array.from(this.constructors.keys())}static setInstance(t,s){this.instances.set(t,s)}static getInstance(t){return this.instances.get(t)}static hasInstance(t){return this.instances.has(t)}}var s;t.constructors=new Map,t.instances=new Map,exports.RouteMethod=void 0,(s=exports.RouteMethod||(exports.RouteMethod={})).GET="GET",s.POST="POST",s.PUT="PUT",s.PATCH="PATCH",s.DELETE="DELETE",s.HEAD="HEAD",s.OPTIONS="OPTIONS",exports.InjectionRegistry=t;

package/dist/common.mjs

@@ -0,0 +1 @@
+class t{static registry(t,s){this.constructors.set(t,s)}static getAll(){return new Map(this.constructors)}static get(t){return this.constructors.get(t)||null}static has(t){return this.constructors.has(t)}static names(){return Array.from(this.constructors.keys())}static setInstance(t,s){this.instances.set(t,s)}static getInstance(t){return this.instances.get(t)}static hasInstance(t){return this.instances.has(t)}}var s;t.constructors=new Map,t.instances=new Map,function(t){t.GET="GET",t.POST="POST",t.PUT="PUT",t.PATCH="PATCH",t.DELETE="DELETE",t.HEAD="HEAD",t.OPTIONS="OPTIONS"}(s||(s={}));export{t as InjectionRegistry,s as RouteMethod};

package/dist/config.d.ts

@@ -0,0 +1,258 @@
+/**
+ * @fileoverview Configuration management module for @mxweb/core framework.
+ * Provides a centralized configuration system similar to @nestjs/config.
+ * @module config
+ */
+import { ApplicationInject } from "./common";
+/**
+ * Configuration management class that provides a centralized way to register
+ * and access application configuration values.
+ *
+ * This class implements the {@link ApplicationInject} interface, allowing it
+ * to be injected into the Application and participate in lifecycle management.
+ *
+ * @remarks
+ * - Configuration must be registered BEFORE importing features
+ * - Supports both synchronous and asynchronous configuration providers
+ * - Uses lazy evaluation - factories are only called when config is first accessed
+ * - Singleton pattern ensures consistent configuration across the application
+ *
+ * @example
+ * ```ts
+ * // Step 1: Register config in config.ts (before importing features)
+ * import { Config } from "@mxweb/core";
+ *
+ * Config.register("dbType", () => "mongodb");
+ * Config.register("apiVersion", () => "v1");
+ * Config.registerAsync("secretKey", async () => await loadSecret());
+ *
+ * // Step 2: Import config before features in route.ts
+ * import "./config";
+ * import "@/features/products/product.feature";
+ *
+ * // Step 3: Inject Config into Application
+ * const app = Application.create({
+ *   injects: {
+ *     config: Config.forRoot(),
+ *   },
+ * });
+ *
+ * // Step 4: Access config values anywhere
+ * const dbType = Config.get<string>("dbType"); // "mongodb"
+ * const secret = await Config.getAsync<string>("secretKey");
+ * ```
+ *
+ * @implements {ApplicationInject}
+ */
+export declare class Config implements ApplicationInject {
+    /** Singleton instance of Config */
+    private static instance;
+    /** Store for resolved configuration values */
+    private static store;
+    /** Map of synchronous configuration factory functions */
+    private static providers;
+    /** Map of asynchronous configuration factory functions */
+    private static asyncProviders;
+    /** Flag indicating if sync providers have been built */
+    private static built;
+    /** Flag indicating if async providers have been built */
+    private static asyncBuilt;
+    /**
+     * Creates and returns the singleton Config instance for injection into Application.
+     *
+     * @returns The singleton Config instance
+     *
+     * @example
+     * ```ts
+     * const app = Application.create({
+     *   injects: {
+     *     config: Config.forRoot(),
+     *   },
+     * });
+     * ```
+     */
+    static forRoot(): Config;
+    /**
+     * ApplicationInject lifecycle hook - called when the inject is initialized.
+     * Builds all async providers to ensure configuration is ready.
+     *
+     * @returns Promise that resolves when all async config is built
+     */
+    onInit(): Promise<void>;
+    /**
+     * Registers a synchronous configuration provider.
+     * The factory function will be called lazily when the config value is first accessed.
+     *
+     * @template T - The type of the configuration value
+     * @param key - Unique key to identify this configuration
+     * @param factory - Factory function that returns the configuration value
+     * @returns The Config class for method chaining
+     *
+     * @example
+     * ```ts
+     * Config.register("port", () => 3000);
+     * Config.register("env", () => process.env.NODE_ENV ?? "development");
+     *
+     * // Method chaining
+     * Config
+     *   .register("db.host", () => "localhost")
+     *   .register("db.port", () => 5432);
+     * ```
+     */
+    static register<T = unknown>(key: string, factory: () => T): typeof Config;
+    /**
+     * Registers an asynchronous configuration provider.
+     * The factory function will be called lazily when buildAsync() is invoked.
+     *
+     * @template T - The type of the configuration value
+     * @param key - Unique key to identify this configuration
+     * @param factory - Async factory function that returns the configuration value
+     * @returns The Config class for method chaining
+     *
+     * @example
+     * ```ts
+     * Config.registerAsync("secretKey", async () => {
+     *   return await fetchSecretFromVault();
+     * });
+     *
+     * Config.registerAsync("remoteConfig", async () => {
+     *   const response = await fetch("https://config.example.com/app");
+     *   return response.json();
+     * });
+     * ```
+     */
+    static registerAsync<T = unknown>(key: string, factory: () => T | Promise<T>): typeof Config;
+    /**
+     * Builds all synchronous providers and stores their values.
+     * This method is idempotent - subsequent calls have no effect.
+     *
+     * @remarks
+     * Called automatically when accessing config via {@link get} or {@link getOrThrow}.
+     */
+    private static build;
+    /**
+     * Builds all providers (sync and async) and stores their values.
+     * This method is idempotent - subsequent calls have no effect.
+     *
+     * @remarks
+     * Called automatically when accessing config via {@link getAsync} or {@link getAsyncOrThrow}.
+     * Also called during {@link onInit} lifecycle hook.
+     */
+    private static buildAsync;
+    /**
+     * Retrieves a configuration value by key (synchronous).
+     * Automatically builds sync providers if not already built.
+     *
+     * @template T - The expected type of the configuration value
+     * @param key - The configuration key to retrieve
+     * @returns The configuration value or undefined if not found
+     *
+     * @remarks
+     * This method only returns values from sync providers.
+     * For async providers, use {@link getAsync}.
+     *
+     * @example
+     * ```ts
+     * const port = Config.get<number>("port"); // 3000
+     * const missing = Config.get("nonexistent"); // undefined
+     * ```
+     */
+    static get<T = unknown>(key: string): T | undefined;
+    /**
+     * Retrieves a configuration value by key (asynchronous).
+     * Automatically builds all providers (sync + async) if not already built.
+     *
+     * @template T - The expected type of the configuration value
+     * @param key - The configuration key to retrieve
+     * @returns Promise resolving to the configuration value or undefined if not found
+     *
+     * @example
+     * ```ts
+     * const secret = await Config.getAsync<string>("secretKey");
+     * const remoteConfig = await Config.getAsync<RemoteConfig>("remoteConfig");
+     * ```
+     */
+    static getAsync<T = unknown>(key: string): Promise<T | undefined>;
+    /**
+     * Retrieves a configuration value by key, throwing an error if not found (synchronous).
+     *
+     * @template T - The expected type of the configuration value
+     * @param key - The configuration key to retrieve
+     * @returns The configuration value
+     * @throws {Error} If the configuration key is not found
+     *
+     * @example
+     * ```ts
+     * const port = Config.getOrThrow<number>("port"); // 3000
+     * const missing = Config.getOrThrow("nonexistent"); // throws Error
+     * ```
+     */
+    static getOrThrow<T = unknown>(key: string): T;
+    /**
+     * Retrieves a configuration value by key, throwing an error if not found (asynchronous).
+     *
+     * @template T - The expected type of the configuration value
+     * @param key - The configuration key to retrieve
+     * @returns Promise resolving to the configuration value
+     * @throws {Error} If the configuration key is not found
+     *
+     * @example
+     * ```ts
+     * const secret = await Config.getAsyncOrThrow<string>("secretKey");
+     * ```
+     */
+    static getAsyncOrThrow<T = unknown>(key: string): Promise<T>;
+    /**
+     * Checks if a configuration key exists (registered or already built).
+     *
+     * @param key - The configuration key to check
+     * @returns true if the key exists, false otherwise
+     *
+     * @example
+     * ```ts
+     * if (Config.has("featureFlag")) {
+     *   // Feature is configured
+     * }
+     * ```
+     */
+    static has(key: string): boolean;
+    /**
+     * Returns a copy of all built configuration values.
+     *
+     * @returns A new Map containing all built configuration key-value pairs
+     *
+     * @remarks
+     * Only includes values that have already been built.
+     * Call after {@link buildAsync} to ensure all values are included.
+     *
+     * @example
+     * ```ts
+     * await Config.getAsync("anyKey"); // Ensure all are built
+     * const allConfig = Config.getAll();
+     * for (const [key, value] of allConfig) {
+     *   console.log(`${key}: ${value}`);
+     * }
+     * ```
+     */
+    static getAll(): Map<string, unknown>;
+    /**
+     * Resets all configuration state.
+     * Primarily used for testing to ensure clean state between tests.
+     *
+     * @remarks
+     * This method clears:
+     * - The singleton instance
+     * - All stored values
+     * - All registered providers (sync and async)
+     * - Build flags
+     *
+     * @example
+     * ```ts
+     * // In test setup/teardown
+     * beforeEach(() => {
+     *   Config.reset();
+     * });
+     * ```
+     */
+    static reset(): void;
+}

package/dist/config.js

@@ -0,0 +1 @@
+"use strict";class t{static forRoot(){return t.instance||(t.instance=new t),t.instance}async onInit(){await t.buildAsync()}static register(s,r){return t.providers.set(s,r),t}static registerAsync(s,r){return t.asyncProviders.set(s,r),t}static build(){if(!t.built){for(const[s,r]of t.providers)t.store.has(s)||t.store.set(s,r());t.built=!0}}static async buildAsync(){if(t.build(),!t.asyncBuilt){for(const[s,r]of t.asyncProviders)t.store.has(s)||t.store.set(s,await r());t.asyncBuilt=!0}}static get(s){return t.build(),t.store.get(s)}static async getAsync(s){return await t.buildAsync(),t.store.get(s)}static getOrThrow(s){if(t.build(),!t.store.has(s))throw new Error(`[Config] Config key "${s}" not found`);return t.store.get(s)}static async getAsyncOrThrow(s){if(await t.buildAsync(),!t.store.has(s))throw new Error(`[Config] Config key "${s}" not found`);return t.store.get(s)}static has(s){return t.store.has(s)||t.providers.has(s)||t.asyncProviders.has(s)}static getAll(){return new Map(t.store)}static reset(){t.instance=null,t.store.clear(),t.providers.clear(),t.asyncProviders.clear(),t.built=!1,t.asyncBuilt=!1}}t.instance=null,t.store=new Map,t.providers=new Map,t.asyncProviders=new Map,t.built=!1,t.asyncBuilt=!1,exports.Config=t;

package/dist/config.mjs

@@ -0,0 +1 @@
+class t{static forRoot(){return t.instance||(t.instance=new t),t.instance}async onInit(){await t.buildAsync()}static register(s,r){return t.providers.set(s,r),t}static registerAsync(s,r){return t.asyncProviders.set(s,r),t}static build(){if(!t.built){for(const[s,r]of t.providers)t.store.has(s)||t.store.set(s,r());t.built=!0}}static async buildAsync(){if(t.build(),!t.asyncBuilt){for(const[s,r]of t.asyncProviders)t.store.has(s)||t.store.set(s,await r());t.asyncBuilt=!0}}static get(s){return t.build(),t.store.get(s)}static async getAsync(s){return await t.buildAsync(),t.store.get(s)}static getOrThrow(s){if(t.build(),!t.store.has(s))throw new Error(`[Config] Config key "${s}" not found`);return t.store.get(s)}static async getAsyncOrThrow(s){if(await t.buildAsync(),!t.store.has(s))throw new Error(`[Config] Config key "${s}" not found`);return t.store.get(s)}static has(s){return t.store.has(s)||t.providers.has(s)||t.asyncProviders.has(s)}static getAll(){return new Map(t.store)}static reset(){t.instance=null,t.store.clear(),t.providers.clear(),t.asyncProviders.clear(),t.built=!1,t.asyncBuilt=!1}}t.instance=null,t.store=new Map,t.providers=new Map,t.asyncProviders=new Map,t.built=!1,t.asyncBuilt=!1;export{t as Config};

package/dist/context.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @fileoverview Internal context module for request-scoped state management.
+ * This module provides access to the singleton ExecuteContext instance.
+ *
+ * @remarks
+ * **INTERNAL USE ONLY** - This module is not exported from the package.
+ * It provides a convenient way to access the ExecuteContext singleton
+ * throughout the framework internals without importing ExecuteContext directly.
+ *
+ * @internal
+ * @module context
+ */
+import { ExecuteContext } from "./execute";
+/**
+ * Singleton ExecuteContext instance for managing request-scoped state.
+ *
+ * This instance uses AsyncLocalStorage to maintain request context across
+ * async operations, allowing services and controllers to access request
+ * data without explicit parameter passing.
+ *
+ * @remarks
+ * **INTERNAL USE ONLY** - Do not export from the package.
+ *
+ * Used internally by:
+ * - Application: To run handlers within request scope
+ * - Controller: To access request context via `this.context`
+ * - Service: To access request context via `this.context`
+ * - Decorators: To extract request data (Body, Query, Params, etc.)
+ *
+ * @internal
+ *
+ * @example
+ * ```ts
+ * // Internal usage in a module
+ * import { executeContext } from "./context";
+ *
+ * // Run code within request scope
+ * await executeContext.run(requestContext, async () => {
+ *   // Access context anywhere in this scope
+ *   const ctx = executeContext.getContext();
+ * });
+ *
+ * // Access HTTP helpers
+ * const body = await executeContext.switchHttp().json();
+ * const params = executeContext.switchHttp().params();
+ * ```
+ */
+export declare const executeContext: ExecuteContext;

package/dist/context.js

@@ -0,0 +1 @@
+"use strict";const e=require("./execute.js").ExecuteContext.instance;exports.executeContext=e;

package/dist/context.mjs

@@ -0,0 +1 @@
+import{ExecuteContext as e}from"./execute.mjs";const t=e.instance;export{t as executeContext};