@cldmv/slothlet 2.6.3 → 2.7.1

package/dist/lib/runtime/runtime-livebindings.mjs

@@ -256,7 +256,73 @@ export function runWithCtx(ctx, fn, thisArg, args) {
 
 	try {
 		
-		return Reflect.apply(fn, thisArg, args);
+		if (!ctx.hookManager?.enabled || !fn.__slothletPath) {
+			return Reflect.apply(fn, thisArg, args);
+		}
+
+		
+		const path = fn.__slothletPath;
+
+		try {
+			
+			const beforeResult = ctx.hookManager.executeBeforeHooks(path, args);
+
+			
+			if (beforeResult.cancelled) {
+				ctx.hookManager.executeAlwaysHooks(path, beforeResult.value, []);
+				return beforeResult.value;
+			}
+
+			
+			const actualArgs = beforeResult.args;
+
+			
+			const result = Reflect.apply(fn, thisArg, actualArgs);
+
+			
+			if (result && typeof result === "object" && typeof result.then === "function") {
+				return result.then(
+					(resolvedResult) => {
+						
+						const finalResult = ctx.hookManager.executeAfterHooks(path, resolvedResult);
+						ctx.hookManager.executeAlwaysHooks(path, finalResult, []);
+						return finalResult;
+					},
+					(error) => {
+						
+						if (!ctx.hookManager.reportedErrors.has(error)) {
+							ctx.hookManager.reportedErrors.add(error);
+							ctx.hookManager.executeErrorHooks(path, error, { type: "function" });
+						}
+						
+						ctx.hookManager.executeAlwaysHooks(path, undefined, [error]);
+						
+						if (!ctx.hookManager.suppressErrors) {
+							throw error;
+						}
+						return undefined; 
+					}
+				);
+			}
+
+			
+			const finalResult = ctx.hookManager.executeAfterHooks(path, result);
+			ctx.hookManager.executeAlwaysHooks(path, finalResult, []);
+			return finalResult;
+		} catch (error) {
+			
+			if (!ctx.hookManager.reportedErrors.has(error)) {
+				ctx.hookManager.reportedErrors.add(error);
+				ctx.hookManager.executeErrorHooks(path, error, { type: "function" });
+			}
+			
+			ctx.hookManager.executeAlwaysHooks(path, undefined, [error]);
+			
+			if (!ctx.hookManager.suppressErrors) {
+				throw error;
+			}
+			return undefined; 
+		}
 	} finally {
 		
 		setActiveInstance(previousActiveInstance);
@@ -264,11 +330,67 @@ export function runWithCtx(ctx, fn, thisArg, args) {
 }
 
 
-export function makeWrapper(_) {
-	return function wrapperFunction(obj) {
-		
+export function makeWrapper(ctx) {
+	const cache = new WeakMap();
+
+	return function wrapperFunction(obj, currentPath = "") {
+		if (obj == null || (typeof obj !== "object" && typeof obj !== "function")) {
+			return obj;
+		}
+
 		
-		return obj;
+		if (cache.has(obj)) {
+			return cache.get(obj);
+		}
+
+		const proxied = new Proxy(obj, {
+			apply(target, thisArg, args) {
+				
+				return runWithCtx(ctx, target, thisArg, args);
+			},
+			get(target, prop, receiver) {
+				const value = Reflect.get(target, prop, receiver);
+
+				
+				const newPath = currentPath ? `${currentPath}.${String(prop)}` : String(prop);
+
+				
+				const isInternalProperty = currentPath === "" && ["hooks", "__ctx", "shutdown", "_impl"].includes(String(prop));
+				const isInternalPath =
+					newPath === "hooks" ||
+					newPath.startsWith("hooks.") ||
+					newPath === "__ctx" ||
+					newPath.startsWith("__ctx.") ||
+					newPath === "shutdown" ||
+					newPath.startsWith("shutdown.") ||
+					newPath === "_impl" ||
+					newPath.startsWith("_impl.");
+
+				
+				if (typeof value === "function" && !value.__slothletPath && !isInternalProperty && !isInternalPath) {
+					try {
+						Object.defineProperty(value, "__slothletPath", {
+							value: newPath,
+							writable: false,
+							enumerable: false,
+							configurable: true
+						});
+					} catch {
+						
+					}
+				}
+
+				
+				if ((typeof value === "function" || (value && typeof value === "object")) && !isInternalPath) {
+					return wrapperFunction(value, newPath);
+				}
+
+				return value;
+			}
+		});
+
+		cache.set(obj, proxied);
+		return proxied;
 	};
 }
 

package/dist/slothlet.mjs

@@ -31,6 +31,8 @@ import {
 	buildCategoryDecisions
 } from "@cldmv/slothlet/helpers/api_builder";
 import { updateInstanceData, cleanupInstance } from "./lib/helpers/instance-manager.mjs";
+import { disableAlsForEventEmitters, cleanupAllSlothletListeners } from "./lib/helpers/als-eventemitter.mjs";
+import { HookManager } from "./lib/helpers/hooks.mjs";
 
 
 
@@ -222,11 +224,34 @@ const slothletObject = {
 		if (executionEngine === "singleton") {
 			
 			
-			const { context = null, reference = null, sanitize = null, engine, mode, ...loadConfig } = options;
+			const { context = null, reference = null, sanitize = null, hooks = false, engine, mode, ...loadConfig } = options;
 			this.context = context;
 			this.reference = reference;
 
 			
+			let hooksEnabled = false;
+			let hooksPattern = null;
+			let hooksSuppressErrors = false;
+
+			if (hooks === true || hooks === false) {
+				
+				hooksEnabled = hooks;
+				hooksPattern = hooks ? "**" : null;
+			} else if (typeof hooks === "string") {
+				
+				hooksEnabled = true;
+				hooksPattern = hooks;
+			} else if (hooks && typeof hooks === "object") {
+				
+				hooksEnabled = hooks.enabled !== false; 
+				hooksPattern = hooks.pattern || "**";
+				hooksSuppressErrors = hooks.suppressErrors || false;
+			}
+
+			
+			this.hookManager = new HookManager(hooksEnabled, hooksPattern, { suppressErrors: hooksSuppressErrors });
+
+			
 			if (sanitize !== null) {
 				this.config.sanitize = sanitize;
 			}
@@ -253,6 +278,8 @@ const slothletObject = {
 			await this.load(loadConfig, { context, reference });
 
 			
+
+			
 			
 			return this.boundapi;
 		} else {
@@ -310,6 +337,27 @@ const slothletObject = {
 		} else {
 			this.api = await this.modes.eager.create.call(this, apiDir, this.config.apiDepth || Infinity, 0);
 		}
+
+		
+		if (this.hookManager) {
+			const hooksApi = {
+				on: (name, type, handler, options) => this.hookManager.on(name, type, handler, options),
+				off: (idOrPattern) => this.hookManager.off(idOrPattern),
+				enable: (pattern) => this.hookManager.enable(pattern),
+				disable: () => this.hookManager.disable(),
+				clear: (type) => this.hookManager.clear(type),
+				list: (type) => this.hookManager.list(type)
+			};
+
+			
+			Object.defineProperty(this.api, "hooks", {
+				value: hooksApi,
+				writable: false,
+				enumerable: true,
+				configurable: true
+			});
+		}
+
 		if (this.config.debug) console.log(this.api);
 
 		
@@ -899,7 +947,8 @@ const slothletObject = {
 		this.safeDefine(this.boundapi, "__ctx", {
 			self: this.boundapi,
 			context: this.context,
-			reference: this.reference
+			reference: this.reference,
+			hookManager: this.hookManager
 		});
 	},
 
@@ -1104,12 +1153,30 @@ const slothletObject = {
 				this._boundAPIShutdown = null;
 
 				
+				if (this.hookManager) {
+					this.hookManager.cleanup();
+					this.hookManager = null;
+				}
+
+				
 
 				
 				if (this.instanceId) {
 					await cleanupInstance(this.instanceId);
 				}
 
+				
+				
+				try {
+					
+					cleanupAllSlothletListeners();
+					
+					disableAlsForEventEmitters();
+				} catch (cleanupError) {
+					
+					console.warn("[slothlet] Warning: EventEmitter cleanup failed:", cleanupError.message);
+				}
+
 				if (apiError || internalError) throw apiError || internalError;
 			}
 		} finally {

package/package.json

@@ -1,9 +1,9 @@
 {
 	"name": "@cldmv/slothlet",
-	"version": "2.6.3",
+	"version": "2.7.1",
 	"moduleVersions": {
-		"lazy": "1.3.0",
-		"eager": "1.3.0"
+		"lazy": "1.3.1",
+		"eager": "1.3.1"
 	},
 	"description": "Slothlet: Modular API Loader for Node.js. Lazy mode dynamically loads API modules and submodules only when accessed, supporting both lazy and eager loading.",
 	"main": "./index.cjs",
@@ -188,6 +188,9 @@
 		"index.cjs",
 		"README.md",
 		"LICENSE",
+		"API-RULES.md",
+		"API-RULES-CONDITIONS.md",
+		"AGENT-USAGE.md",
 		"types/dist/",
 		"types/index.d.mts",
 		"types/index.d.mts.map",

package/types/dist/lib/helpers/als-eventemitter.d.mts

@@ -19,5 +19,38 @@
  * enableAlsForEventEmitters(als);
  */
 export function enableAlsForEventEmitters(als?: AsyncLocalStorage<any>): void;
+/**
+ * Disable AsyncLocalStorage context propagation for EventEmitter instances.
+ *
+ * @function disableAlsForEventEmitters
+ * @package
+ *
+ * @description
+ * Restores original EventEmitter methods, removing the AsyncLocalStorage
+ * context propagation. This should be called during cleanup to prevent
+ * hanging AsyncResource instances that can keep the event loop alive.
+ *
+ * @example
+ * // Disable ALS patching during shutdown
+ * disableAlsForEventEmitters();
+ */
+/**
+ * Clean up ALL listeners that went through slothlet's EventEmitter patching.
+ *
+ * @function cleanupAllSlothletListeners
+ * @package
+ *
+ * @description
+ * Removes all event listeners that were registered through slothlet's patched
+ * EventEmitter methods. This includes listeners from third-party libraries
+ * that got wrapped with AsyncResource instances. This nuclear cleanup option
+ * should be called during shutdown to prevent hanging listeners.
+ *
+ * @example
+ * // Clean up all patched listeners during shutdown
+ * cleanupAllSlothletListeners();
+ */
+export function cleanupAllSlothletListeners(): void;
+export function disableAlsForEventEmitters(): void;
 import { AsyncLocalStorage } from "node:async_hooks";
 //# sourceMappingURL=als-eventemitter.d.mts.map

package/types/dist/lib/helpers/als-eventemitter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"als-eventemitter.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/als-eventemitter.mjs"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,8EAqJC;kCA9KiC,kBAAkB"}
+{"version":3,"file":"als-eventemitter.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/als-eventemitter.mjs"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,8EAiNC;AAED;;;;;;;;;;;;;;GAcG;AACH;;;;;;;;;;;;;;;GAeG;AACH,oDAyBC;AAED,mDAmCC;kCApViC,kBAAkB"}

package/types/dist/lib/helpers/hooks.d.mts

@@ -0,0 +1,342 @@
+/**
+ * @class HookManager
+ * @internal
+ * @private
+ *
+ * @description
+ * Manages registration, pattern matching, and execution of hooks for slothlet API calls.
+ * Hooks are executed in priority order (higher priority first), then registration order.
+ *
+ * @example
+ * // Create hook manager
+ * const manager = new HookManager();
+ * manager.on("logger", "before", (ctx) => { console.log(ctx.path); });
+ */
+export class HookManager {
+    /**
+     * @constructor
+     * @param {boolean} [enabled=true] - Initial enabled state
+     * @param {string} [defaultPattern="**"] - Default pattern for filtering
+     * @param {object} [options={}] - Additional options
+     * @param {boolean} [options.suppressErrors=false] - If true, errors are logged but not thrown (except for before/after hooks)
+     */
+    constructor(enabled?: boolean, defaultPattern?: string, options?: {
+        suppressErrors?: boolean;
+    });
+    enabled: boolean;
+    defaultPattern: string;
+    suppressErrors: boolean;
+    hooks: Map<any, any>;
+    registrationOrder: number;
+    reportedErrors: WeakSet<object>;
+    /**
+     * @function on
+     * @public
+     * @param {string} name - Hook name/ID for debugging and removal
+     * @param {string} type - Hook type: "before", "after", "always", or "error"
+     * @param {Function} handler - Hook handler function with type-specific signature:
+     *   - before: ({ path, args }) => modified args array or value to short-circuit
+     *   - after: ({ path, result }) => transformed result
+     *   - always: ({ path, result, hasError, errors }) => void (read-only)
+     *   - error: ({ path, error, errorType, source }) => void (observer)
+     * @param {object} [options] - Registration options
+     * @param {number} [options.priority=100] - Execution priority (higher = earlier)
+     * @param {string} [options.pattern] - Glob pattern for path filtering
+     * @returns {string} Hook name/ID for later removal
+     *
+     * @description
+     * Register a hook with optional priority and pattern filtering.
+     *
+     * @example
+     * // Register hook with priority
+     * manager.on("validator", "before", handler, { priority: 200 });
+     */
+    public on(name: string, type: string, handler: Function, options?: {
+        priority?: number;
+        pattern?: string;
+    }): string;
+    /**
+     * Clean up all hooks and resources
+     * @public
+     * @description
+     * Clears all registered hooks and resets internal state.
+     * Should be called during shutdown to prevent memory leaks.
+     *
+     * @example
+     * // Clean up during shutdown
+     * manager.cleanup();
+     */
+    public cleanup(): void;
+    /**
+     * @function off
+     * @public
+     * @param {string} nameOrPattern - Hook name or glob pattern to remove
+     * @returns {boolean} True if one or more hooks were removed
+     *
+     * @description
+     * Remove registered hook(s) by exact name or pattern matching.
+     *
+     * @example
+     * // Remove hook by exact name
+     * manager.off("validator");
+     *
+     * @example
+     * // Remove all hooks matching pattern
+     * manager.off("math.*");
+     */
+    public off(nameOrPattern: string): boolean;
+    /**
+     * @function clear
+     * @public
+     * @param {string} [type] - Optional hook type to clear ("before", "after", "always", "error")
+     * @returns {void}
+     *
+     * @description
+     * Remove registered hooks. If type is provided, only hooks of that type are removed.
+     *
+     * @example
+     * // Clear all hooks
+     * manager.clear();
+     *
+     * @example
+     * // Clear only before hooks
+     * manager.clear("before");
+     */
+    public clear(type?: string): void;
+    /**
+     * @function list
+     * @public
+     * @param {string} [type] - Optional hook type to filter by ("before", "after", "always", "error")
+     * @returns {Array<object>} Array of hook metadata
+     *
+     * @description
+     * List registered hooks with their metadata. When type is provided, only hooks
+     * matching that type are returned.
+     *
+     * @example
+     * // List all hooks
+     * const hooks = manager.list();
+     *
+     * @example
+     * // List only before hooks
+     * const beforeHooks = manager.list("before");
+     */
+    public list(type?: string): Array<object>;
+    /**
+     * @function enable
+     * @public
+     * @param {string} [pattern] - Optional new default pattern
+     * @returns {void}
+     *
+     * @description
+     * Enable hook execution, optionally updating default pattern.
+     *
+     * @example
+     * // Enable with new pattern
+     * manager.enable("database.*");
+     */
+    public enable(pattern?: string): void;
+    /**
+     * @function disable
+     * @public
+     * @returns {void}
+     *
+     * @description
+     * Disable hook execution (fast-path bypass).
+     *
+     * @example
+     * // Disable hooks
+     * manager.disable();
+     */
+    public disable(): void;
+    /**
+     * @function executeBeforeHooks
+     * @internal
+     * @private
+     * @param {string} path - Function path (e.g., "database.users.create")
+     * @param {Array} args - Function arguments
+     * @returns {{cancelled: boolean, value?: any, args: Array}} Execution result
+     *
+     * @description
+     * Execute before hooks in priority order. Returns object indicating if execution
+     * should be cancelled (short-circuited) and potentially modified arguments.
+     *
+     * Hook return semantics:
+     * - undefined: continue to next hook/function
+     * - Array: modified arguments for next hook/function
+     * - Other value: short-circuit and return this value
+     *
+     * @example
+     * // Execute before hooks
+     * const result = manager.executeBeforeHooks("database.users.create", [data]);
+     * if (result.cancelled) return result.value;
+     */
+    private executeBeforeHooks;
+    /**
+     * @function executeAfterHooks
+     * @internal
+     * @private
+     * @param {string} path - Function path
+     * @param {any} initialResult - Initial result from function
+     * @returns {any} Transformed result
+     *
+     * @description
+     * Execute after hooks in priority order, chaining results through each hook.
+     * Each hook receives the previous hook's return value (or initial result).
+     * After hooks only run if the function actually executed (not short-circuited).
+     *
+     * @example
+     * // Execute after hooks with chaining
+     * const finalResult = manager.executeAfterHooks("database.users.create", result);
+     */
+    private executeAfterHooks;
+    /**
+     * @function executeAlwaysHooks
+     * @internal
+     * @private
+     * @param {string} path - Function path
+     * @param {any} result - Final result (from function or short-circuit)
+     * @param {Array<Error>} [errors=[]] - Array of errors that occurred during execution
+     * @returns {void}
+     *
+     * @description
+     * Execute always hooks (like finally blocks). These hooks always run regardless
+     * of whether execution was short-circuited, completed normally, or threw errors.
+     * Always hooks receive full execution context including both errors and results,
+     * allowing a single hook to handle all logging scenarios.
+     *
+     * @example
+     * // Execute always hooks with success result
+     * manager.executeAlwaysHooks("database.users.create", result, []);
+     *
+     * @example
+     * // Execute always hooks with error context
+     * manager.executeAlwaysHooks("database.users.create", undefined, [error]);
+     */
+    private executeAlwaysHooks;
+    /**
+     * @function executeErrorHooks
+     * @internal
+     * @private
+     * @param {string} path - Function path
+     * @param {Error} error - Error that was thrown
+     * @param {Object} [source] - Source information about where error originated
+     * @param {string} source.type - Source type: 'before', 'function', 'after', 'always'
+     * @param {string} [source.hookId] - Hook ID if error came from a hook
+     * @param {string} [source.hookTag] - Hook tag if error came from a hook
+     * @returns {void}
+     *
+     * @description
+     * Execute error hooks (observers only, errors bubble naturally).
+     * Provides detailed context about where the error originated.
+     *
+     * @example
+     * // Execute error hooks with source info
+     * manager.executeErrorHooks("database.users.create", error, {
+     *   type: 'before',
+     *   hookId: 'hook-123',
+     *   hookTag: 'validation'
+     * });
+     */
+    private executeErrorHooks;
+    /**
+     * @function _getMatchingHooks
+     * @internal
+     * @private
+     * @param {string} type - Hook type to match
+     * @param {string} path - Function path to test against patterns
+     * @returns {Array<object>} Sorted array of matching hooks
+     *
+     * @description
+     * Get hooks matching type and path, sorted by priority (DESC) then order (ASC).
+     *
+     * @example
+     * // Get matching hooks
+     * const hooks = manager._getMatchingHooks("before", "database.users.create");
+     */
+    private _getMatchingHooks;
+    /**
+     * @function _compilePattern
+     * @internal
+     * @private
+     * @param {string} pattern - Glob pattern string
+     * @returns {RegExp|null} Compiled RegExp or null for negation patterns
+     *
+     * @description
+     * Compile glob pattern to RegExp with support for:
+     * - `*`: single-level wildcard
+     * - `**`: multi-level wildcard
+     * - `{users,posts}`: brace expansion (max 10 nesting levels)
+     * - `!internal.*`: negation patterns
+     *
+     * @example
+     * // Compile pattern
+     * const regex = manager._compilePattern("database.*.create");
+     */
+    private _compilePattern;
+    /**
+     * @function _expandBraces
+     * @internal
+     * @private
+     * @param {string} pattern - Pattern with potential braces
+     * @param {number} [depth=0] - Current nesting depth
+     * @returns {Array<string>} Expanded pattern alternatives
+     *
+     * @description
+     * Expand brace patterns like `{users,posts}` to multiple alternatives.
+     * Limits nesting to MAX_BRACE_NESTING to prevent performance issues.
+     *
+     * @example
+     * // Expand braces
+     * const patterns = manager._expandBraces("{users,posts}.create");
+     * // Returns: ["users.create", "posts.create"]
+     */
+    private _expandBraces;
+    /**
+     * @function _splitAlternatives
+     * @internal
+     * @private
+     * @param {string} str - String to split on commas
+     * @returns {Array<string>} Split alternatives
+     *
+     * @description
+     * Split brace content on commas, respecting nested braces.
+     *
+     * @example
+     * // Split alternatives
+     * const alts = manager._splitAlternatives("users,posts,{admin,guest}");
+     */
+    private _splitAlternatives;
+    /**
+     * @function _patternToRegex
+     * @internal
+     * @private
+     * @param {string} pattern - Pattern without braces
+     * @returns {string} Regex pattern string
+     *
+     * @description
+     * Convert glob pattern to regex pattern string.
+     *
+     * @example
+     * // Convert pattern
+     * const regex = manager._patternToRegex("database.*.create");
+     */
+    private _patternToRegex;
+    /**
+     * @function _matchPattern
+     * @internal
+     * @private
+     * @param {RegExp|object} compiledPattern - Compiled pattern or negation object
+     * @param {string} path - Path to test
+     * @returns {boolean} True if path matches pattern
+     *
+     * @description
+     * Test if path matches compiled pattern, handling negation.
+     *
+     * @example
+     * // Match pattern
+     * const matches = manager._matchPattern(compiledPattern, "database.users.create");
+     */
+    private _matchPattern;
+}
+//# sourceMappingURL=hooks.d.mts.map

package/types/dist/lib/helpers/hooks.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/hooks.mjs"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;GAaG;AACH;IACC;;;;;;OAMG;IACH,sBALW,OAAO,mBACP,MAAM,YAEd;QAA0B,cAAc,GAAhC,OAAO;KACjB,EAQA;IANA,iBAAsB;IACtB,uBAAoC;IACpC,wBAAqD;IACrD,qBAAsB;IACtB,0BAA0B;IAC1B,gCAAmC;IAGpC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,gBAnBW,MAAM,QACN,MAAM,+BAOd;QAAyB,QAAQ,GAAzB,MAAM;QACW,OAAO,GAAxB,MAAM;KACd,GAAU,MAAM,CA0BlB;IAED;;;;;;;;;;OAUG;IACH,uBAKC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,0BAdW,MAAM,GACJ,OAAO,CA6BnB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,oBAdW,MAAM,GACJ,IAAI,CA0BhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,mBAfW,MAAM,GACJ,KAAK,CAAC,MAAM,CAAC,CA4BzB;IAED;;;;;;;;;;;;OAYG;IACH,wBAVW,MAAM,GACJ,IAAI,CAchB;IAED;;;;;;;;;;;OAWG;IACH,kBATa,IAAI,CAWhB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,2BAkCC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,0BAwBC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,2BAqBC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,0BAyBC;IAED;;;;;;;;;;;;;;OAcG;IACH,0BAkBC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,wBAmBC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBA4CC;IAED;;;;;;;;;;;;;OAaG;IACH,2BAuBC;IAED;;;;;;;;;;;;;OAaG;IACH,wBAiBC;IAED;;;;;;;;;;;;;;OAcG;IACH,sBAOC;CACD"}

package/types/dist/lib/runtime/runtime-asynclocalstorage.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-asynclocalstorage.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime-asynclocalstorage.mjs"],"names":[],"mappings":"AAuCA;;;;;GAKG;AACH,wBAHU,qBAAqB,CAGkB;AAsB1C,gCAdI,MAAM,yBAEN,GAAG,gBAED,GAAG,CA6Bf;AAiBM,0BAZM,MAAM,GAAC,IAAI,CAY0B;AAkN3C,iCAjBI,MAAM,YAuIhB;AAuSD;;;;;;;;;;;;;GAaG;AACH,mBATU,WAAS,MAAM,CAS6B;AAEtD;;;;;;;;;;;;;GAaG;AACH,sBATU,MAAM,CAS4C;AAE5D;;;;;;;;;;;;;GAaG;AACH,wBATU,MAAM,CASgD;;kCAnuB9B,kBAAkB"}
+{"version":3,"file":"runtime-asynclocalstorage.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime-asynclocalstorage.mjs"],"names":[],"mappings":"AAuCA;;;;;GAKG;AACH,wBAHU,qBAAqB,CAGkB;AAsB1C,gCAdI,MAAM,yBAEN,GAAG,gBAED,GAAG,CAoGf;AAiBM,0BAZM,MAAM,GAAC,IAAI,CAY0B;AAkN3C,iCAjBI,MAAM,YAiJhB;AAuSD;;;;;;;;;;;;;GAaG;AACH,mBATU,WAAS,MAAM,CAS6B;AAEtD;;;;;;;;;;;;;GAaG;AACH,sBATU,MAAM,CAS4C;AAE5D;;;;;;;;;;;;;GAaG;AACH,wBATU,MAAM,CASgD;;kCApzB9B,kBAAkB"}