@cldmv/slothlet 2.6.3 → 2.7.1

package/dist/lib/helpers/hooks.mjs

@@ -0,0 +1,389 @@
+/*
+	Copyright 2025 CLDMV/Shinrai
+
+	Licensed under the Apache License, Version 2.0 (the "License");
+	you may not use this file except in compliance with the License.
+	You may obtain a copy of the License at
+
+		http://www.apache.org/licenses/LICENSE-2.0
+
+	Unless required by applicable law or agreed to in writing, software
+	distributed under the License is distributed on an "AS IS" BASIS,
+	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	See the License for the specific language governing permissions and
+	limitations under the License.
+*/
+
+
+
+
+
+const MAX_BRACE_NESTING = 10;
+
+
+export class HookManager {
+	
+	constructor(enabled = true, defaultPattern = "**", options = {}) {
+		this.enabled = enabled;
+		this.defaultPattern = defaultPattern;
+		this.suppressErrors = options.suppressErrors || false;
+		this.hooks = new Map(); 
+		this.registrationOrder = 0; 
+		this.reportedErrors = new WeakSet(); 
+	}
+
+	
+	on(name, type, handler, options = {}) {
+		const priority = options.priority ?? 100;
+		const pattern = options.pattern || this.defaultPattern;
+		const compiledPattern = this._compilePattern(pattern);
+		const order = this.registrationOrder++;
+
+		this.hooks.set(name, {
+			tag: name,
+			type,
+			handler,
+			priority,
+			pattern,
+			compiledPattern,
+			order
+		});
+
+		return name;
+	}
+
+	
+	cleanup() {
+		this.hooks.clear();
+		this.reportedErrors = new WeakSet();
+		this.registrationOrder = 0;
+		this.enabled = false;
+	}
+
+	
+	off(nameOrPattern) {
+		
+		if (this.hooks.has(nameOrPattern)) {
+			return this.hooks.delete(nameOrPattern);
+		}
+
+		
+		const compiled = this._compilePattern(nameOrPattern);
+		let removed = false;
+		for (const key of [...this.hooks.keys()]) {
+			if (this._matchPattern(compiled, key)) {
+				this.hooks.delete(key);
+				removed = true;
+			}
+		}
+		return removed;
+	}
+
+	
+	clear(type) {
+		if (type === undefined) {
+			this.hooks.clear();
+			this.registrationOrder = 0;
+			return;
+		}
+
+		
+		for (const [name, hook] of this.hooks) {
+			if (hook.type === type) {
+				this.hooks.delete(name);
+			}
+		}
+	}
+
+	
+	list(type) {
+		const result = [];
+		for (const [name, hook] of this.hooks) {
+			if (type === undefined || hook.type === type) {
+				result.push({
+					name,
+					type: hook.type,
+					priority: hook.priority,
+					pattern: hook.pattern,
+					order: hook.order
+				});
+			}
+		}
+		return result;
+	}
+
+	
+	enable(pattern) {
+		this.enabled = true;
+		if (pattern !== undefined) {
+			this.defaultPattern = pattern;
+		}
+	}
+
+	
+	disable() {
+		this.enabled = false;
+	}
+
+	
+	executeBeforeHooks(path, args) {
+		const hooks = this._getMatchingHooks("before", path);
+		let currentArgs = args;
+
+		for (const hook of hooks) {
+			try {
+				const result = hook.handler({ path, args: currentArgs });
+
+				
+				if (result === undefined) {
+					continue;
+				}
+
+				
+				if (Array.isArray(result)) {
+					currentArgs = result;
+					continue;
+				}
+
+				
+				return { cancelled: true, value: result, args: currentArgs };
+			} catch (error) {
+				
+				this.reportedErrors.add(error);
+				this.executeErrorHooks(path, error, {
+					type: "before",
+					hookId: hook.id,
+					hookTag: hook.tag
+				});
+				throw error;
+			}
+		}
+
+		return { cancelled: false, args: currentArgs };
+	}
+
+	
+	executeAfterHooks(path, initialResult) {
+		const hooks = this._getMatchingHooks("after", path);
+		let currentResult = initialResult;
+
+		for (const hook of hooks) {
+			try {
+				const transformed = hook.handler({ path, result: currentResult });
+				
+				if (transformed !== undefined) {
+					currentResult = transformed;
+				}
+			} catch (error) {
+				
+				this.reportedErrors.add(error);
+				this.executeErrorHooks(path, error, {
+					type: "after",
+					hookId: hook.id,
+					hookTag: hook.tag
+				});
+				throw error;
+			}
+		}
+
+		return currentResult;
+	}
+
+	
+	executeAlwaysHooks(path, result, errors = []) {
+		const hooks = this._getMatchingHooks("always", path);
+
+		for (const hook of hooks) {
+			try {
+				hook.handler({
+					path,
+					result,
+					hasError: errors.length > 0,
+					errors
+				});
+			} catch (error) {
+				
+				this.executeErrorHooks(path, error, {
+					type: "always",
+					hookId: hook.id,
+					hookTag: hook.tag
+				});
+				
+			}
+		}
+	}
+
+	
+	executeErrorHooks(path, error, source = { type: "unknown" }) {
+		const hooks = this._getMatchingHooks("error", path);
+
+		
+		const errorContext = {
+			path,
+			error,
+			errorType: error.constructor ? error.constructor.name : "Error",
+			source: {
+				type: source.type || "unknown",
+				hookId: source.hookId,
+				hookTag: source.hookTag,
+				timestamp: Date.now(),
+				stack: error.stack
+			}
+		};
+
+		for (const hook of hooks) {
+			try {
+				hook.handler(errorContext);
+			} catch (hookError) {
+				
+				console.error(`Error in error hook for ${path}:`, hookError);
+			}
+		}
+	}
+
+	
+	_getMatchingHooks(type, path) {
+		const matching = [];
+
+		for (const [hookId, hook] of this.hooks.entries()) {
+			if (hook.type !== type) continue;
+			if (!this._matchPattern(hook.compiledPattern, path)) continue;
+			matching.push({ ...hook, id: hookId });
+		}
+
+		
+		matching.sort((a, b) => {
+			if (a.priority !== b.priority) {
+				return b.priority - a.priority; 
+			}
+			return a.order - b.order; 
+		});
+
+		return matching;
+	}
+
+	
+	_compilePattern(pattern) {
+		
+		if (pattern.startsWith("!")) {
+			return {
+				negation: true,
+				regex: this._compilePattern(pattern.slice(1))
+			};
+		}
+
+		
+		const expanded = this._expandBraces(pattern);
+		if (expanded.length > 1) {
+			
+			const regexes = expanded.map((p) => this._patternToRegex(p));
+			return new RegExp(`^(?:${regexes.join("|")})$`);
+		}
+
+		
+		return new RegExp(`^${this._patternToRegex(expanded[0])}$`);
+	}
+
+	
+	_expandBraces(pattern, depth = 0) {
+		if (depth > MAX_BRACE_NESTING) {
+			throw new Error(`Brace expansion exceeds maximum nesting depth of ${MAX_BRACE_NESTING}`);
+		}
+
+		const braceStart = pattern.indexOf("{");
+		if (braceStart === -1) {
+			return [pattern];
+		}
+
+		
+		let braceEnd = -1;
+		let nestLevel = 0;
+		for (let i = braceStart; i < pattern.length; i++) {
+			if (pattern[i] === "{") nestLevel++;
+			if (pattern[i] === "}") {
+				nestLevel--;
+				if (nestLevel === 0) {
+					braceEnd = i;
+					break;
+				}
+			}
+		}
+
+		if (braceEnd === -1) {
+			
+			return [pattern];
+		}
+
+		const before = pattern.slice(0, braceStart);
+		const inside = pattern.slice(braceStart + 1, braceEnd);
+		const after = pattern.slice(braceEnd + 1);
+
+		
+		const alternatives = this._splitAlternatives(inside);
+
+		
+		const results = [];
+		for (const alt of alternatives) {
+			const expanded = this._expandBraces(before + alt + after, depth + 1);
+			results.push(...expanded);
+		}
+
+		return results;
+	}
+
+	
+	_splitAlternatives(str) {
+		const alternatives = [];
+		let current = "";
+		let nestLevel = 0;
+
+		for (let i = 0; i < str.length; i++) {
+			const char = str[i];
+			if (char === "{") nestLevel++;
+			if (char === "}") nestLevel--;
+
+			if (char === "," && nestLevel === 0) {
+				alternatives.push(current);
+				current = "";
+			} else {
+				current += char;
+			}
+		}
+
+		if (current) {
+			alternatives.push(current);
+		}
+
+		return alternatives;
+	}
+
+	
+	_patternToRegex(pattern) {
+		
+		let regex = pattern.replace(/[+?^${}()|[\]\\]/g, "\\$&");
+
+		
+		regex = regex.replace(/\./g, "\\.");
+
+		
+		regex = regex.replace(/\*\*/g, "___DOUBLESTAR___");
+
+		
+		regex = regex.replace(/\*/g, "([^\\.]+)");
+
+		
+		regex = regex.replace(/___DOUBLESTAR___/g, ".*?");
+
+		return regex;
+	}
+
+	
+	_matchPattern(compiledPattern, path) {
+		if (compiledPattern.negation) {
+			
+			return !this._matchPattern(compiledPattern.regex, path);
+		}
+
+		return compiledPattern.test(path);
+	}
+}

package/dist/lib/modes/slothlet_lazy.mjs

@@ -341,6 +341,10 @@ function createFolderProxy({ subDirPath, key, parent, instance, depth, maxDepth,
 			if (prop === "_materialize") return _materialize;
 			if (prop === "then") return undefined; 
 			
+			if (prop === "__slothletPath") {
+				return pathParts.length > 0 ? pathParts.join(".") : undefined;
+			}
+			
 			if (materialized) {
 				if (materialized && (typeof materialized === "object" || typeof materialized === "function")) return materialized[prop];
 				return undefined;
@@ -348,10 +352,12 @@ function createFolderProxy({ subDirPath, key, parent, instance, depth, maxDepth,
 			
 			if (!inFlight) inFlight = _materialize();
 			
+			const apiPath = pathParts.length > 0 ? `${pathParts.join(".")}.${String(prop)}` : String(prop);
+			
 			
 			
 			
-			return new Proxy(
+			const propertyProxy = new Proxy(
 				
 				function lazy_propertyAccessor(...args) {
 					return inFlight.then(
@@ -360,12 +366,7 @@ function createFolderProxy({ subDirPath, key, parent, instance, depth, maxDepth,
 							const value = resolved ? resolved[prop] : undefined;
 							if (typeof value === "function") {
 								
-								const ctx = instance.boundapi?.__ctx;
-								if (ctx) {
-									return runWithCtx(ctx, value, this, args);
-								} else {
-									return value.apply(this, args);
-								}
+								return value.apply(this, args);
 							}
 							return value;
 						}
@@ -377,6 +378,10 @@ function createFolderProxy({ subDirPath, key, parent, instance, depth, maxDepth,
 						if (subProp === "name") return `lazy_${prop}`;
 						if (subProp === "length") return 0;
 						
+						if (subProp === "__slothletPath") {
+							return pathParts.length > 0 ? `${pathParts.join(".")}.${String(prop)}` : String(prop);
+						}
+						
 						return new Proxy(
 							 function lazy_deepPropertyAccessor() {},
 							{
@@ -390,12 +395,8 @@ function createFolderProxy({ subDirPath, key, parent, instance, depth, maxDepth,
 												const value = materialized[prop];
 												const subValue = value ? value[subProp] : undefined;
 												if (subValue && typeof subValue[nextProp] === "function") {
-													const ctx = instance.boundapi?.__ctx;
-													if (ctx) {
-														return runWithCtx(ctx, subValue[nextProp], thisArg, args);
-													} else {
-														return subValue[nextProp].apply(thisArg, args);
-													}
+													
+													return subValue[nextProp].apply(thisArg, args);
 												}
 												return subValue ? subValue[nextProp] : undefined;
 											}
@@ -423,12 +424,7 @@ function createFolderProxy({ subDirPath, key, parent, instance, depth, maxDepth,
 										const value = materialized[prop];
 										if (value && typeof value[subProp] === "function") {
 											
-											const ctx = instance.boundapi?.__ctx;
-											if (ctx) {
-												return runWithCtx(ctx, value[subProp], thisArg, args);
-											} else {
-												return value[subProp].apply(thisArg, args);
-											}
+											return value[subProp].apply(thisArg, args);
 										}
 										return value ? value[subProp] : undefined;
 									}
@@ -457,6 +453,16 @@ function createFolderProxy({ subDirPath, key, parent, instance, depth, maxDepth,
 					}
 				}
 			);
+
+			
+			Object.defineProperty(propertyProxy, "__slothletPath", {
+				value: apiPath,
+				writable: false,
+				enumerable: false,
+				configurable: true
+			});
+
+			return propertyProxy;
 		},
 		has(_t, prop) {
 			if (materialized && (typeof materialized === "object" || typeof materialized === "function")) return prop in materialized;

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

@@ -33,10 +33,81 @@ enableAlsForEventEmitters(als);
 
 export const runWithCtx = (ctx, fn, thisArg, args) => {
 	
+	if (!ctx.hookManager?.enabled || !fn.__slothletPath) {
+		const runtime_runInALS = () => {
+			const result = Reflect.apply(fn, thisArg, args);
+			return result;
+		};
+		return als.run(ctx, runtime_runInALS);
+	}
+
+	
+	const path = fn.__slothletPath;
+
+	
 	const runtime_runInALS = () => {
-		const result = Reflect.apply(fn, thisArg, args);
-		return result;
+		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; 
+		}
 	};
+
 	return als.run(ctx, runtime_runInALS);
 };
 
@@ -157,7 +228,7 @@ export const makeWrapper = (ctx) => {
 	const cache = new WeakMap();
 	const instanceCache = new WeakMap();
 	const promiseMethodCache = new WeakMap(); 
-	const wrap = (val) => {
+	const wrap = (val, currentPath = "") => {
 		if (val == null || (typeof val !== "object" && typeof val !== "function")) return val;
 		if (cache.has(val)) return cache.get(val);
 
@@ -170,17 +241,6 @@ export const makeWrapper = (ctx) => {
 
 		const proxied = new Proxy(val, {
 			apply(target, thisArg, args) {
-				
-				
-				
-				
-				
-				
-				
-				
-				
-				
-
 				const result = runWithCtx(ctx, target, thisArg, args);
 
 				
@@ -205,6 +265,27 @@ export const makeWrapper = (ctx) => {
 				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.startsWith("hooks.") || newPath.startsWith("__ctx.") || newPath.startsWith("shutdown.");
+
+				
+				if (typeof value === "function" && !value.__slothletPath && !isInternalProperty && !isInternalPath) {
+					try {
+						Object.defineProperty(value, "__slothletPath", {
+							value: newPath,
+							writable: false,
+							enumerable: false,
+							configurable: true
+						});
+					} catch {
+						
+					}
+				}
+
+				
 				
 				const isPromiseMethod = typeof value === "function" && PROMISE_METHODS.has(prop);
 				const isNativePromise = util.types.isPromise(target);
@@ -236,14 +317,14 @@ export const makeWrapper = (ctx) => {
 						
 						const result = Reflect.apply(value, target, wrappedArgs);
 						
-						return wrap(result);
+						return wrap(result, newPath);
 					};
 
 					targetMethodCache.set(prop, wrappedMethod);
 					return wrappedMethod;
 				}
 
-				return wrap(value);
+				return wrap(value, newPath);
 			},
 			set(target, prop, value, receiver) {