@routier/core 0.0.6 → 0.1.0-rc.0

package/dist/capabilities/index.js

@@ -9,214 +9,103 @@ __webpack_require__.d(__webpack_exports__, {
   Capability: () => (Capability)
 });
 class Capability {
+    excludedNames = new Set([
+        "Array",
+        "Set",
+        "Map",
+        "AbortController",
+        "AbortSignal",
+        "SchemaString",
+        "SchemaNumber",
+        "SchemaArray",
+        "SchemaBoolean",
+        "SchemaDate",
+        "SchemaObject",
+        "SchemaDefault",
+        "SchemaDeserialize",
+        "SchemaDistinct",
+        "SchemaFrom",
+        "SchemaIdentity",
+        "SchemaIndex",
+        "SchemaKey",
+        "SchemaNullable",
+        "SchemaOptional",
+        "SchemaReadonly",
+        "SchemaSerialize",
+        "SchemaTracked",
+        "SchemaComputed",
+        "SchemaFunction",
+        "SchemaBase",
+        "SchemaDefinition"
+    ]);
     isValidObject(obj) {
         return typeof obj === "object" && obj !== null;
     }
-    getObjectName(obj) {
-        return obj?.constructor?.name || 'root';
-    }
-    exploreObjectMethods(obj, callback, options = {}) {
-        if (!this.isValidObject(obj)) {
-            return;
-        }
-        const { maxDepth = 10, includeNonEnumerable = false, filter = () => true } = options;
-        const rootName = this.getObjectName(obj);
-        const visited = new Set();
-        // Explore root methods
-        this.exploreRootMethods(obj, callback, filter);
-        // Explore nested methods
-        this.exploreNestedMethods(obj, callback, filter, [rootName], visited, maxDepth, includeNonEnumerable);
-    }
-    exploreRootMethods(obj, callback, filter) {
-        const methodNames = this.extractMethodNames(obj);
-        for (const methodName of methodNames) {
-            const methodInfo = {
-                methodName,
-                instance: obj,
-                methodPath: [String(methodName)],
-                parent: null
-            };
-            if (filter(methodInfo)) {
-                callback(methodInfo);
-            }
-        }
-    }
-    extractMethodNames(obj) {
-        const methodNames = new Set();
-        let prototype = obj;
-        while (prototype && prototype !== Object.prototype) {
-            const allKeys = [
-                ...Object.getOwnPropertyNames(prototype),
-                ...Object.getOwnPropertySymbols(prototype),
-            ];
-            for (const key of allKeys) {
-                const descriptor = Object.getOwnPropertyDescriptor(prototype, key);
-                if (this.isCallableMethod(descriptor, key)) {
-                    methodNames.add(key);
-                }
-            }
-            prototype = Object.getPrototypeOf(prototype);
-        }
-        return Array.from(methodNames);
-    }
     isCallableMethod(descriptor, key) {
         return (descriptor?.value &&
             typeof descriptor.value === 'function' &&
             key !== 'constructor' &&
             key !== 'undefined');
     }
-    isCustomClassInstance(value) {
-        if (value === null || (typeof value !== "object" && typeof value !== "function")) {
+    canExplore(descriptor) {
+        if (typeof descriptor.value !== "object") {
             return false;
         }
-        const objectTag = Object.prototype.toString.call(value);
-        // Most built-ins have distinct tags; user classes default to "[object Object]"
-        // Caveat: Symbol.toStringTag can spoof this.
-        return objectTag === "[object Object]";
-    }
-    shouldProcessProperty(property) {
-        return (this.isCustomClassInstance(property) &&
-            property?.constructor.name !== "Object");
-    }
-    exploreNestedMethods(obj, callback, filter, initialPath, visited, maxDepth, includeNonEnumerable) {
-        if (visited.has(obj) || initialPath.length > maxDepth) {
-            return;
-        }
-        visited.add(obj);
-        if (!this.isValidObject(obj)) {
-            return;
+        if (descriptor.value == null) {
+            return false;
         }
-        const properties = includeNonEnumerable
-            ? Object.getOwnPropertyNames(obj)
-            : Object.keys(obj);
-        for (const propertyName of properties) {
-            const property = obj[propertyName];
-            if (!this.shouldProcessProperty(property)) {
-                continue;
-            }
-            const newPath = [...initialPath, propertyName];
-            // Explore methods on this property
-            this.explorePropertyMethods(property, callback, filter, newPath, obj);
-            // Recursively explore nested objects
-            this.exploreNestedMethods(property, callback, filter, newPath, visited, maxDepth, includeNonEnumerable);
+        const name = this.getName(descriptor.value);
+        if (name == null) {
+            return true;
         }
+        return this.excludedNames.has(name) === false;
     }
-    explorePropertyMethods(property, callback, filter, methodPath, parent) {
-        const methodNames = this.extractMethodNames(property);
-        for (const methodName of methodNames) {
-            const fullMethodPath = [...methodPath, String(methodName)];
-            const methodInfo = {
-                methodName,
-                instance: property,
-                methodPath: fullMethodPath,
-                parent
-            };
-            if (filter(methodInfo)) {
-                callback(methodInfo);
-            }
+    getName(value) {
+        if (value.constructor != null) {
+            return value.constructor.name;
         }
+        return null;
     }
-    stringifyValue(value, maxDepth = 3, currentDepth = 0) {
-        if (value === null)
-            return 'null';
-        if (value === undefined)
-            return 'undefined';
-        const type = typeof value;
-        switch (type) {
-            case 'string':
-                return `"${value}"`;
-            case 'number':
-            case 'boolean':
-                return String(value);
-            case 'function':
-                return `[Function: ${this.getFunctionName(value)}]`;
-            case 'object':
-                if (currentDepth >= maxDepth) {
-                    return '[Max Depth Reached]';
-                }
-                return this.stringifyObject(value, maxDepth, currentDepth);
-            default:
-                return `[${type}]`;
+    getPath(info, propertyName) {
+        let parent = info.parent;
+        const path = [info.propertyName, propertyName];
+        while (parent != null) {
+            path.unshift(parent.propertyName);
+            parent = parent.parent;
         }
+        return path.join(".");
     }
-    getFunctionName(fn) {
-        const name = fn.name;
-        return name || 'anonymous';
-    }
-    stringifyObject(obj, maxDepth, currentDepth) {
-        if (obj === null)
-            return 'null';
-        // Handle special object types
-        if (obj instanceof Date) {
-            return `Date(${obj.toISOString()})`;
-        }
-        if (obj instanceof Error) {
-            return `Error(${obj.message})`;
-        }
-        if (obj instanceof RegExp) {
-            return obj.toString();
-        }
-        if (Array.isArray(obj)) {
-            return this.stringifyArray(obj, maxDepth, currentDepth);
-        }
-        if (obj.constructor && obj.constructor.name !== 'Object') {
-            return this.stringifyClassInstance(obj, maxDepth, currentDepth);
-        }
-        return this.stringifyPlainObject(obj, maxDepth, currentDepth);
-    }
-    stringifyArray(arr, maxDepth, currentDepth) {
-        if (arr.length === 0)
-            return '[]';
-        const items = arr.slice(0, 5).map(item => this.stringifyValue(item, maxDepth, currentDepth + 1));
-        const suffix = arr.length > 5 ? `... (+${arr.length - 5} more)` : '';
-        return `[${items.join(', ')}${suffix}]`;
-    }
-    stringifyClassInstance(obj, maxDepth, currentDepth) {
-        const className = obj.constructor.name;
-        const properties = this.getObjectProperties(obj);
-        if (Object.keys(properties).length === 0) {
-            return `${className} {}`;
-        }
-        const props = Object.entries(properties)
-            .slice(0, 5)
-            .map(([key, value]) => {
-            // For primitive values, don't increase depth
-            const isPrimitive = value === null || value === undefined ||
-                (typeof value !== 'object' && typeof value !== 'function');
-            const depth = isPrimitive ? currentDepth : currentDepth + 1;
-            return `${key}: ${this.stringifyValue(value, maxDepth, depth)}`;
-        });
-        const suffix = Object.keys(properties).length > 5 ?
-            `... (+${Object.keys(properties).length - 5} more)` : '';
-        return `${className} { ${props.join(', ')}${suffix} }`;
-    }
-    stringifyPlainObject(obj, maxDepth, currentDepth) {
-        const properties = this.getObjectProperties(obj);
-        if (Object.keys(properties).length === 0) {
-            return '{}';
+    explore(instance, onDiscover) {
+        if (!this.isValidObject(instance)) {
+            return;
         }
-        const props = Object.entries(properties)
-            .slice(0, 5)
-            .map(([key, value]) => {
-            // For primitive values, don't increase depth
-            const isPrimitive = value === null || value === undefined ||
-                (typeof value !== 'object' && typeof value !== 'function');
-            const depth = isPrimitive ? currentDepth : currentDepth + 1;
-            return `${key}: ${this.stringifyValue(value, maxDepth, depth)}`;
-        });
-        const suffix = Object.keys(properties).length > 5 ?
-            `... (+${Object.keys(properties).length - 5} more)` : '';
-        return `{ ${props.join(', ')}${suffix} }`;
-    }
-    getObjectProperties(obj) {
-        const properties = {};
-        // Get enumerable properties
-        for (const key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                properties[key] = obj[key];
+        const explore = [{ instance, propertyName: this.getName(instance) }];
+        const visited = new Set();
+        for (let i = 0; i < explore.length; i++) {
+            const info = explore[i];
+            const item = info.instance;
+            if (visited.has(item)) {
+                continue;
             }
+            const allKeys = [
+                ...Object.getOwnPropertyNames(item),
+                ...Object.getOwnPropertySymbols(item),
+            ];
+            for (const key of allKeys) {
+                const descriptor = Object.getOwnPropertyDescriptor(item, key);
+                const isCallable = this.isCallableMethod(descriptor, key);
+                onDiscover(info, {
+                    name: key,
+                    isCallable
+                });
+                if (this.canExplore(descriptor) === false) {
+                    continue;
+                }
+                const path = this.getPath(info, key);
+                explore.push({ instance: descriptor.value, parent: info, propertyName: key, path });
+            }
+            visited.add(item);
         }
-        return properties;
     }
 }
 
@@ -231,99 +120,134 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
   PerformanceCapability: () => (PerformanceCapability)
 });
+/* ESM import */var _utilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utilities */ "./src/utilities/strings.ts");
 /* ESM import */var _Capability__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Capability */ "./src/capabilities/Capability.ts");
 /* ESM import */var _performance_PerformanceTracker__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./performance/PerformanceTracker */ "./src/capabilities/performance/PerformanceTracker.ts");
 /* ESM import */var _tracing_CallTraceManager__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./tracing/CallTraceManager */ "./src/capabilities/tracing/CallTraceManager.ts");
 
 
 
+
 class PerformanceCapability extends _Capability__WEBPACK_IMPORTED_MODULE_0__.Capability {
     callTraceManager;
     performanceTracker;
-    log;
-    shouldLog;
+    filter;
+    childDurations = new Map();
     constructor(options) {
         super();
-        this.log = options?.log ?? ((type, operationId, methodName, methodPath, performanceMetrics, isCompleted) => {
-            if (isCompleted) {
-                if (!performanceMetrics.duration)
-                    return;
-                const deltaFromStart = this.performanceTracker.getDeltaFromOperationStart(operationId, performanceMetrics.endTime || performanceMetrics.startTime);
-                console.log(`[${type} ${operationId}] ${methodName} COMPLETED`, {
-                    methodPath,
-                    performance: {
-                        deltaFromStart: this.performanceTracker.formatDuration(deltaFromStart),
-                        executionTime: this.performanceTracker.formatDuration(performanceMetrics.duration),
-                        timeToNextCall: performanceMetrics.timeToNextCall ?
-                            this.performanceTracker.formatDuration(performanceMetrics.timeToNextCall) : 'N/A'
-                    }
-                });
-                return;
-            }
-            const deltaFromStart = this.performanceTracker.getDeltaFromOperationStart(operationId, performanceMetrics.startTime);
-            console.log(`[${type} ${operationId}] ${methodName}`, {
-                methodPath,
-                performance: {
-                    deltaFromStart: this.performanceTracker.formatDuration(deltaFromStart)
-                }
-            });
-        });
-        this.shouldLog = options?.shouldLog ?? (() => true);
+        this.filter = options?.filter ?? (() => true);
         this.callTraceManager = new _tracing_CallTraceManager__WEBPACK_IMPORTED_MODULE_1__.CallTraceManager();
         this.performanceTracker = new _performance_PerformanceTracker__WEBPACK_IMPORTED_MODULE_2__.PerformanceTracker();
     }
-    createPerformanceInterceptor(originalMethod, methodName, methodPath, instance) {
-        return (...args) => {
-            const isNewOperation = this.callTraceManager.isNewOperation();
-            let operationId;
-            if (isNewOperation) {
-                operationId = this.callTraceManager.startNewOperation();
-                const startTime = this.performanceTracker.startMethodTiming(operationId, methodPath);
-                this.log('ORIGIN', operationId, methodName, methodPath, { startTime }, false);
-            }
-            else {
-                operationId = this.callTraceManager.getActiveOperationId();
-                // Record that the previous method is about to call this one
-                const callTrace = this.callTraceManager.getCurrentTrace();
-                const previousMethodPath = callTrace[callTrace.length - 2];
-                if (previousMethodPath) {
-                    this.performanceTracker.recordNextMethodStart(operationId, previousMethodPath);
-                }
-                const startTime = this.performanceTracker.startMethodTiming(operationId, methodPath);
-                this.log('CHILD', operationId, methodName, methodPath, { startTime }, false);
-            }
-            try {
-                const result = originalMethod.apply(instance, args);
-                return result;
-            }
-            finally {
-                // End performance tracking
-                const performanceMetrics = this.performanceTracker.endMethodTiming(operationId, methodPath);
-                // Log completion with performance metrics
-                this.log(isNewOperation ? 'ORIGIN' : 'CHILD', operationId, methodName, methodPath, performanceMetrics, true);
-                if (isNewOperation) {
-                    this.callTraceManager.endOperation();
-                    this.performanceTracker.cleanupOperation(operationId);
-                }
-            }
-        };
-    }
     apply(instance) {
-        if (!this.isValidObject(instance)) {
-            return;
-        }
-        // Create a performance wrapper
-        const wrapper = {
-            wrapMethod: (originalMethod, methodInfo) => {
-                return this.createPerformanceInterceptor(originalMethod, String(methodInfo.methodName), methodInfo.methodPath.join(' → '), methodInfo.instance);
+        this.explore(instance, (meta, info) => {
+            if (info.isCallable) {
+                const originalMethod = meta.instance[info.name].bind(meta.instance);
+                meta.instance[info.name] = (...args) => {
+                    const path = `${meta.path}.${String(info.name)}()`;
+                    if (this.filter(path, info, meta) === false) {
+                        return originalMethod(...args);
+                    }
+                    const isNewOperation = this.callTraceManager.isNewOperation();
+                    let operationId;
+                    let callTrace;
+                    let depth;
+                    if (isNewOperation) {
+                        operationId = this.callTraceManager.startNewOperation();
+                        this.childDurations.set(operationId, []);
+                        callTrace = this.callTraceManager.addMethodToTrace(path);
+                        depth = callTrace.length - 1;
+                        const formattedCallTrace = this.callTraceManager.formatMethodPaths(callTrace);
+                        this.performanceTracker.startMethodTiming(operationId, path);
+                        console.log(`\n${'═'.repeat(60)}`);
+                        console.log(`▶ ORIGIN [${operationId}] ${path}`);
+                        if (args.length > 0) {
+                            console.log(`  Args:`, (0,_utilities__WEBPACK_IMPORTED_MODULE_3__.stringifyObject)(args, 4, 0));
+                        }
+                        console.log(`  Call Stack: ${formattedCallTrace.join(' → ')}`);
+                    }
+                    else {
+                        operationId = this.callTraceManager.getActiveOperationId();
+                        callTrace = this.callTraceManager.addMethodToTrace(path);
+                        depth = callTrace.length - 1;
+                        const indent = '  '.repeat(Math.min(depth, 4));
+                        // Track children for this child method too
+                        const childMethodKey = `${operationId}:${path}`;
+                        this.childDurations.set(childMethodKey, []);
+                        this.performanceTracker.startMethodTiming(operationId, path);
+                        console.log(`${indent}└─ CHILD [${operationId}] ${path}`);
+                        if (args.length > 0) {
+                            console.log(`${indent}   Args:`, (0,_utilities__WEBPACK_IMPORTED_MODULE_3__.stringifyObject)(args, 4, 0));
+                        }
+                    }
+                    try {
+                        return originalMethod(...args);
+                    }
+                    finally {
+                        const metrics = this.performanceTracker.endMethodTiming(operationId, path);
+                        const duration = metrics.duration ?? 0;
+                        const formattedDuration = this.performanceTracker.formatDuration(duration);
+                        if (isNewOperation) {
+                            const childDurations = this.childDurations.get(operationId) ?? [];
+                            const totalChildTime = childDurations.reduce((sum, d) => sum + d, 0);
+                            const formattedTotalChildTime = this.performanceTracker.formatDuration(totalChildTime);
+                            const overhead = duration - totalChildTime;
+                            const formattedOverhead = this.performanceTracker.formatDuration(Math.max(0, overhead));
+                            console.log(`\n${'═'.repeat(60)}`);
+                            console.log(`◀ COMPLETE [${operationId}] ${path}`);
+                            console.log(`  Total Duration: ${formattedDuration}`);
+                            if (childDurations.length > 0) {
+                                console.log(`  Children Duration: ${formattedTotalChildTime} (${childDurations.length} calls)`);
+                                console.log(`  Overhead: ${formattedOverhead}`);
+                            }
+                            console.log(`${'═'.repeat(60)}\n`);
+                            this.childDurations.delete(operationId);
+                            this.performanceTracker.cleanupOperation(operationId);
+                            this.callTraceManager.endOperation();
+                        }
+                        else {
+                            const indent = '  '.repeat(Math.min(depth, 4));
+                            const childMethodKey = `${operationId}:${path}`;
+                            const childDurations = this.childDurations.get(childMethodKey) ?? [];
+                            const totalChildTime = childDurations.reduce((sum, d) => sum + d, 0);
+                            const formattedTotalChildTime = this.performanceTracker.formatDuration(totalChildTime);
+                            const overhead = duration - totalChildTime;
+                            const formattedOverhead = this.performanceTracker.formatDuration(Math.max(0, overhead));
+                            console.log(`${indent}   ✓ ${formattedDuration}`);
+                            if (childDurations.length > 0) {
+                                console.log(`${indent}     Children: ${formattedTotalChildTime} (${childDurations.length} calls), Overhead: ${formattedOverhead}`);
+                            }
+                            // Clean up child method tracking
+                            this.childDurations.delete(childMethodKey);
+                            // Find the parent method and add this duration to its children list
+                            // The parent is the method one level up in the call trace
+                            const currentTrace = this.callTraceManager.getCurrentTrace();
+                            if (currentTrace.length > 1) {
+                                // Parent is the second-to-last item in the trace (before we remove current)
+                                const parentPath = currentTrace[currentTrace.length - 2];
+                                // Check if parent is the root operation (trace length 2 means root + this child)
+                                if (currentTrace.length === 2) {
+                                    // Direct child of root - add to root's children list
+                                    const rootChildDurations = this.childDurations.get(operationId);
+                                    if (rootChildDurations) {
+                                        rootChildDurations.push(duration);
+                                    }
+                                }
+                                else {
+                                    // Nested child - add to parent method's children list
+                                    const parentMethodKey = `${operationId}:${parentPath}`;
+                                    const parentChildDurations = this.childDurations.get(parentMethodKey);
+                                    if (parentChildDurations) {
+                                        parentChildDurations.push(duration);
+                                    }
+                                }
+                            }
+                        }
+                        this.callTraceManager.removeMethodFromTrace();
+                    }
+                };
             }
-        };
-        // Use the generic interception utility
-        this.exploreObjectMethods(instance, (methodInfo) => {
-            const originalMethod = methodInfo.instance[methodInfo.methodName].bind(methodInfo.instance);
-            const wrappedMethod = wrapper.wrapMethod(originalMethod, methodInfo);
-            methodInfo.instance[methodInfo.methodName] = wrappedMethod;
-        }, {});
+        });
     }
 }
 
@@ -340,95 +264,61 @@ __webpack_require__.d(__webpack_exports__, {
 });
 /* ESM import */var _Capability__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Capability */ "./src/capabilities/Capability.ts");
 /* ESM import */var _tracing_CallTraceManager__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./tracing/CallTraceManager */ "./src/capabilities/tracing/CallTraceManager.ts");
+/* ESM import */var _utilities_strings__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utilities/strings */ "./src/utilities/strings.ts");
+
 
 
 class TracingCapability extends _Capability__WEBPACK_IMPORTED_MODULE_0__.Capability {
     callTraceManager;
-    log;
-    shouldLogMethod;
+    filter;
     constructor(options) {
         super();
-        this.log = options?.log ?? ((type, operationId, methodName, methodPath, _callTrace, formattedCallTrace, args) => {
-            const stringifiedArgs = args.map(arg => this.stringifyValue(arg, 4));
-            const logData = {
-                methodPath,
-                callStack: formattedCallTrace,
-                args: stringifiedArgs
-            };
-            console.log(`[${type} ${operationId}] ${methodName}`, logData);
-        });
-        this.shouldLogMethod = options?.shouldLog ?? (() => true);
+        this.filter = options?.filter ?? (() => true);
         this.callTraceManager = new _tracing_CallTraceManager__WEBPACK_IMPORTED_MODULE_1__.CallTraceManager();
     }
-    createTracingInterceptor(originalMethod, methodName, methodPath, instance) {
-        return (...args) => {
-            const isNewOperation = this.callTraceManager.isNewOperation();
-            let operationId;
-            let callTrace;
-            if (isNewOperation) {
-                operationId = this.callTraceManager.startNewOperation();
-                callTrace = this.callTraceManager.addMethodToTrace(methodPath);
-                const formattedCallTrace = this.callTraceManager.formatMethodPaths(callTrace);
-                this.log('ORIGIN', operationId, methodName, methodPath, callTrace, formattedCallTrace, args);
-            }
-            else {
-                operationId = this.callTraceManager.getActiveOperationId();
-                callTrace = this.callTraceManager.addMethodToTrace(methodPath);
-                const formattedCallTrace = this.callTraceManager.formatMethodPaths(callTrace);
-                this.log('CHILD', operationId, methodName, methodPath, callTrace, formattedCallTrace, args);
-            }
-            try {
-                const result = originalMethod.apply(instance, args);
-                return result;
-            }
-            finally {
-                if (isNewOperation) {
-                    this.callTraceManager.endOperation();
-                }
-                else {
-                    this.callTraceManager.removeMethodFromTrace();
-                }
-            }
-        };
-    }
     apply(instance) {
-        if (!this.isValidObject(instance)) {
-            return;
-        }
-        const logMethodCall = (type, operationId, methodName, methodPath, callTrace, formattedCallTrace, args) => {
-            if (this.log) {
-                this.log(type, operationId, methodName, methodPath, callTrace, formattedCallTrace, args);
-                return;
-            }
-            const stringifiedArgs = args.map(arg => this.stringifyValue(arg, 4));
-            const logData = {
-                methodPath,
-                callStack: formattedCallTrace,
-                args: stringifiedArgs
-            };
-            console.log(`[${type} ${operationId}] ${methodName}`, logData);
-        };
-        // Create a tracing wrapper
-        const wrapper = {
-            wrapMethod: (originalMethod, methodInfo) => {
-                const metadata = {
-                    parent: methodInfo.parent,
-                    instance: methodInfo.instance,
-                    methodPath: methodInfo.methodPath
+        this.explore(instance, (meta, info) => {
+            if (info.isCallable) {
+                const originalMethod = meta.instance[info.name].bind(meta.instance);
+                meta.instance[info.name] = (...args) => {
+                    const path = `${meta.path}.${String(info.name)}()`;
+                    if (this.filter(path, info, meta) === false) {
+                        return originalMethod(...args);
+                    }
+                    const isNewOperation = this.callTraceManager.isNewOperation();
+                    let operationId;
+                    if (isNewOperation) {
+                        operationId = this.callTraceManager.startNewOperation();
+                        const callTrace = this.callTraceManager.addMethodToTrace(path);
+                        const formattedCallTrace = this.callTraceManager.formatMethodPaths(callTrace);
+                        console.log(`\n${'═'.repeat(60)}`);
+                        console.log(`▶ ORIGIN [${operationId}] ${path}`);
+                        if (args.length > 0) {
+                            console.log(`  Args:`, (0,_utilities_strings__WEBPACK_IMPORTED_MODULE_2__.stringifyObject)(args, 4, 0));
+                        }
+                        console.log(`  Call Stack: ${formattedCallTrace.join(' → ')}`);
+                    }
+                    else {
+                        operationId = this.callTraceManager.getActiveOperationId();
+                        const callTrace = this.callTraceManager.addMethodToTrace(path);
+                        const indent = '  '.repeat(Math.min(callTrace.length - 1, 4));
+                        console.log(`${indent}└─ CHILD [${operationId}] ${path}`);
+                        if (args.length > 0) {
+                            console.log(`${indent}   Args:`, (0,_utilities_strings__WEBPACK_IMPORTED_MODULE_2__.stringifyObject)(args, 4, 0));
+                        }
+                    }
+                    try {
+                        return originalMethod(...args);
+                    }
+                    finally {
+                        this.callTraceManager.removeMethodFromTrace();
+                        if (isNewOperation) {
+                            this.callTraceManager.endOperation();
+                        }
+                    }
                 };
-                const shouldLog = this.shouldLogMethod(methodInfo.methodName, metadata);
-                if (!shouldLog) {
-                    return originalMethod; // Return unwrapped method if not logging
-                }
-                return this.createTracingInterceptor(originalMethod, String(methodInfo.methodName), methodInfo.methodPath.join(' → '), methodInfo.instance);
             }
-        };
-        // Use the generic interception utility
-        this.exploreObjectMethods(instance, (methodInfo) => {
-            const originalMethod = methodInfo.instance[methodInfo.methodName].bind(methodInfo.instance);
-            const wrappedMethod = wrapper.wrapMethod(originalMethod, methodInfo);
-            methodInfo.instance[methodInfo.methodName] = wrappedMethod;
-        }, {});
+        });
     }
 }
 
@@ -520,7 +410,7 @@ class CallTraceManager {
     activeOperationId = null;
     activeCallStack = [];
     startNewOperation() {
-        const operationId = (0,_utilities__WEBPACK_IMPORTED_MODULE_0__.uuid)();
+        const operationId = (0,_utilities__WEBPACK_IMPORTED_MODULE_0__.uuid)(8);
         this.activeOperationId = operationId;
         this.activeCallStack = [];
         return operationId;
@@ -561,6 +451,172 @@ class CallTraceManager {
 }
 
 
+}),
+"./src/utilities/strings.ts": 
+/*!**********************************!*\
+  !*** ./src/utilities/strings.ts ***!
+  \**********************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  fastHash: () => (fastHash),
+  hash: () => (hash),
+  stringifyObject: () => (stringifyObject)
+});
+const hash = (value, seed = 0) => {
+    // From Stack Overflow
+    // https://stackoverflow.com/a/52171480/3329760
+    let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
+    for (let i = 0, ch; i < value.length; i++) {
+        ch = value.charCodeAt(i);
+        h1 = Math.imul(h1 ^ ch, 2654435761);
+        h2 = Math.imul(h2 ^ ch, 1597334677);
+    }
+    h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
+    h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+    h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
+    h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+    return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+};
+/**
+ * Fast string hash optimized for comparisons.
+ * Uses djb2 algorithm - very fast and good distribution for short to medium strings.
+ * Same input always produces same output (deterministic).
+ *
+ * @param value - The string to hash
+ * @param seed - Optional seed value (default: 5381)
+ * @returns A positive 32-bit integer hash value
+ *
+ * @example
+ * ```ts
+ * fastHash("test") === fastHash("test") // true
+ * fastHash("test") !== fastHash("test2") // true
+ * ```
+ */
+const fastHash = (value, seed = 5381) => {
+    let hash = seed;
+    for (let i = 0; i < value.length; i++) {
+        hash = ((hash << 5) + hash) + value.charCodeAt(i);
+    }
+    return hash >>> 0; // Convert to unsigned 32-bit integer
+};
+/**
+ * Converts any value to a readable string representation.
+ * Handles primitives, objects, arrays, classes, dates, errors, and functions.
+ * Supports depth limiting to prevent infinite recursion on circular references.
+ *
+ * @param obj - The value to stringify
+ * @param maxDepth - Maximum depth for nested objects (default: 3)
+ * @param currentDepth - Current recursion depth (default: 0)
+ * @returns String representation of the value
+ *
+ * @example
+ * ```ts
+ * stringifyObject({ name: "test", count: 5 }) // '{ name: "test", count: 5 }'
+ * stringifyObject([1, 2, 3]) // '[1, 2, 3]'
+ * stringifyObject(new Date()) // 'Date(2024-01-01T00:00:00.000Z)'
+ * ```
+ */
+function stringifyObject(obj, maxDepth = 3, currentDepth = 0) {
+    if (obj === null)
+        return 'null';
+    if (obj === undefined)
+        return 'undefined';
+    const type = typeof obj;
+    switch (type) {
+        case 'string':
+            return `"${obj}"`;
+        case 'number':
+        case 'boolean':
+            return String(obj);
+        case 'function':
+            return `[Function: ${getFunctionName(obj)}]`;
+        case 'object':
+            if (currentDepth >= maxDepth) {
+                return '[Max Depth Reached]';
+            }
+            return stringifyObjectValue(obj, maxDepth, currentDepth);
+        default:
+            return `[${type}]`;
+    }
+}
+function getFunctionName(fn) {
+    const name = fn.name;
+    return name || 'anonymous';
+}
+function getObjectProperties(obj) {
+    const properties = {};
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            properties[key] = obj[key];
+        }
+    }
+    return properties;
+}
+function stringifyObjectValue(obj, maxDepth, currentDepth) {
+    if (obj === null)
+        return 'null';
+    if (obj instanceof Date) {
+        return `Date(${obj.toISOString()})`;
+    }
+    if (obj instanceof Error) {
+        return `Error(${obj.message})`;
+    }
+    if (obj instanceof RegExp) {
+        return obj.toString();
+    }
+    if (Array.isArray(obj)) {
+        return stringifyArray(obj, maxDepth, currentDepth);
+    }
+    if (obj.constructor && obj.constructor.name !== 'Object') {
+        return stringifyClassInstance(obj, maxDepth, currentDepth);
+    }
+    return stringifyPlainObject(obj, maxDepth, currentDepth);
+}
+function stringifyArray(arr, maxDepth, currentDepth) {
+    if (arr.length === 0)
+        return '[]';
+    const items = arr.slice(0, 5).map(item => stringifyObject(item, maxDepth, currentDepth + 1));
+    const suffix = arr.length > 5 ? `... (+${arr.length - 5} more)` : '';
+    return `[${items.join(', ')}${suffix}]`;
+}
+function stringifyClassInstance(obj, maxDepth, currentDepth) {
+    const className = obj.constructor.name;
+    const properties = getObjectProperties(obj);
+    if (Object.keys(properties).length === 0) {
+        return `${className} {}`;
+    }
+    const props = Object.entries(properties)
+        .slice(0, 5)
+        .map(([key, value]) => {
+        const isPrimitive = value === null || value === undefined ||
+            (typeof value !== 'object' && typeof value !== 'function');
+        const depth = isPrimitive ? currentDepth : currentDepth + 1;
+        return `${key}: ${stringifyObject(value, maxDepth, depth)}`;
+    });
+    const suffix = Object.keys(properties).length > 5 ?
+        `... (+${Object.keys(properties).length - 5} more)` : '';
+    return `${className} { ${props.join(', ')}${suffix} }`;
+}
+function stringifyPlainObject(obj, maxDepth, currentDepth) {
+    const properties = getObjectProperties(obj);
+    if (Object.keys(properties).length === 0) {
+        return '{}';
+    }
+    const props = Object.entries(properties)
+        .slice(0, 5)
+        .map(([key, value]) => {
+        const isPrimitive = value === null || value === undefined ||
+            (typeof value !== 'object' && typeof value !== 'function');
+        const depth = isPrimitive ? currentDepth : currentDepth + 1;
+        return `${key}: ${stringifyObject(value, maxDepth, depth)}`;
+    });
+    const suffix = Object.keys(properties).length > 5 ?
+        `... (+${Object.keys(properties).length - 5} more)` : '';
+    return `{ ${props.join(', ')}${suffix} }`;
+}
+
+
 }),
 "./src/utilities/uuid.ts": 
 /*!*******************************!*\