@routier/core 0.2.1 → 0.3.0

package/dist/capabilities/index.cjs

@@ -0,0 +1,820 @@
+(() => {
+"use strict";
+var __webpack_modules__ = ({
+581(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  vF: () => (logger)
+});
+/**
+ * Levelled logging, resolved once.
+ *
+ * Three things about the previous implementation drove this shape:
+ *
+ *  - **There was no way to turn logging off.** `globalThis.__ROUTIER_DEBUG__` was only ever
+ *    compared against `true`, so setting it to `false` did nothing — while
+ *    `docs/how-to/debug-logging.md` documented exactly that as the way to force logging off.
+ *    A documented switch that silently does nothing is worse than no switch.
+ *  - **`NODE_ENV === 'test'` enabled it.** Every Jest run therefore logged, because Jest always
+ *    sets `NODE_ENV=test`. Measured on the S7 stress scenario, which drives ~2,000 saves through
+ *    a plugin that logs three lines per query: 12.4s with logging, ~6s without. Test runners also
+ *    capture console output by snapshotting a stack trace per call, so the cost is far above what
+ *    writing to a terminal would suggest — and the output buries whatever the failure was.
+ *  - **It was all-or-nothing, and re-resolved per call.** An error could not be kept while debug
+ *    was dropped, and every one of the ~97 call sites re-read `globalThis` and `process.env`.
+ *
+ * Levels are compared numerically against a value cached at module load. Measured against a
+ * no-op console at 200k calls: an enabled call costs ~70ns, a call rejected by the gate ~3ns.
+ * Building the arguments the call site passes in accounts for ~0.2ns of that 3ns, which is why
+ * this keeps the ordinary `logger.debug(msg, payload)` signature instead of taking a thunk —
+ * a lazy API would recover 0.3% of an enabled call's cost and would have to change every call
+ * site to do it.
+ */ /** Ordered from most severe to most verbose. `silent` discards everything. */ const LOG_LEVELS = [
+    'silent',
+    'error',
+    'warn',
+    'info',
+    'debug'
+];
+/** Numeric rank, so a gate is one integer comparison. */ const RANK = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4
+};
+const isLogLevel = (value)=>typeof value === 'string' && LOG_LEVELS.includes(value);
+/**
+ * Resolves the configured level, in precedence order.
+ *
+ * Ordered most specific first: an explicit level beats a boolean flag, a boolean flag beats an
+ * environment variable, and an environment variable beats an inference from `NODE_ENV`. Anything
+ * unrecognised is ignored rather than treated as an error — a typo'd level should not take down
+ * an application, and `silent` is the safe direction to fall back to.
+ */ const resolveLevel = ()=>{
+    if (typeof globalThis !== 'undefined') {
+        const g = globalThis;
+        if (isLogLevel(g.__ROUTIER_LOG_LEVEL__)) {
+            return g.__ROUTIER_LOG_LEVEL__;
+        }
+        // Both directions honoured. `=== false` used to fall through to the NODE_ENV checks
+        // below and re-enable the logging it was asked to suppress.
+        if (g.__ROUTIER_DEBUG__ === true) return 'debug';
+        if (g.__ROUTIER_DEBUG__ === false) return 'silent';
+    }
+    // There is deliberately no `import.meta.env` branch, although the documentation used to
+    // promise one. It could never work: this package is bundled with rspack, which replaces
+    // `import.meta` with `undefined`, so the check would read the *library's* build-time
+    // environment rather than the application's — and referencing `import.meta` at all is a parse
+    // error under a CommonJS build target, which is how the test suite loads this file. Vite and
+    // similar apps set `__ROUTIER_LOG_LEVEL__` or `__ROUTIER_DEBUG__` from their own
+    // `import.meta.env`, which is what the docs now describe.
+    if (typeof process !== 'undefined' && process.env != null) {
+        if (isLogLevel(process.env.ROUTIER_LOG_LEVEL)) {
+            return process.env.ROUTIER_LOG_LEVEL;
+        }
+        const debug = process.env.DEBUG;
+        if (debug === 'routier' || debug === '*') return 'debug';
+        const env = "production"?.toLowerCase();
+        // `test` is deliberately absent. It used to be here, which meant no test suite anywhere
+        // could run Routier quietly. Opt in with DEBUG=routier or ROUTIER_LOG_LEVEL when a test
+        // needs the output.
+        if (env === 'dev' || env === 'development') return 'debug';
+    }
+    return 'silent';
+};
+let level = resolveLevel();
+let rank = RANK[level];
+/**
+ * Overrides the level for the rest of the process.
+ *
+ * The configuration above is read once, at import, which is what makes the gate cheap — but it
+ * also means an application that decides its verbosity after startup, or a test that wants to
+ * assert on output, has no way in. This is that way in.
+ */ const setLogLevel = (next)=>{
+    if (isLogLevel(next) === false) {
+        throw new Error(`Unknown log level "${next}". Expected one of: ${LOG_LEVELS.join(', ')}`);
+    }
+    level = next;
+    rank = RANK[next];
+};
+const getLogLevel = ()=>level;
+/** Re-reads the environment. For tests that change it after this module was imported. */ const resetLogLevel = ()=>{
+    level = resolveLevel();
+    rank = RANK[level];
+};
+/**
+ * Whether a message at this level would be emitted.
+ *
+ * For the rare call site whose *arguments* are expensive to build — a serialization, a deep
+ * clone, a join over a large collection. An ordinary payload object is not worth guarding; see
+ * the measurement in the header.
+ */ const isLogLevelEnabled = (at)=>rank >= RANK[at];
+const emit = (at, method, args)=>{
+    if (rank < RANK[at]) {
+        return;
+    }
+    // Resolved at call time rather than captured once: test harnesses and browser devtools both
+    // replace console methods after modules have loaded, and a captured reference would keep
+    // writing past the replacement.
+    console[method](...args);
+};
+const logger = {
+    /** General-purpose output. Carried at `info`, since `log` names a console method, not a level. */ log: (...args)=>emit('info', 'log', args),
+    info: (...args)=>emit('info', 'info', args),
+    warn: (...args)=>emit('warn', 'warn', args),
+    error: (...args)=>emit('error', 'error', args),
+    debug: (...args)=>emit('debug', 'debug', args),
+    /** Diagnostic tabular output; verbose by nature, so it sits at `debug`. */ table: (...args)=>emit('debug', 'table', args)
+};
+
+
+},
+615(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  Zm: () => (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} }`;
+}
+
+
+},
+618(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  u: () => (uuid)
+});
+const uuid = (length = 16)=>{
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const charLength = chars.length;
+    let result = '';
+    for(let i = 0; i < length; i++){
+        result += chars[Math.random() * charLength | 0];
+    }
+    return result;
+};
+const HEX_CHARS = '0123456789abcdef';
+const UUID_TEMPLATE = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+const hasCrypto = typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function';
+const hasRandomUUID = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function';
+const uuidv4 = ()=>{
+    if (hasRandomUUID) {
+        return crypto.randomUUID();
+    }
+    return uuidv4Fallback();
+};
+const uuidv4Fallback = ()=>{
+    let randomBytes = null;
+    if (hasCrypto) {
+        randomBytes = crypto.getRandomValues(new Uint8Array(16));
+    }
+    let byteIndex = 0;
+    let uuid = '';
+    for(let i = 0; i < UUID_TEMPLATE.length; i++){
+        const c = UUID_TEMPLATE[i];
+        if (c === '-') {
+            uuid += '-';
+            continue;
+        }
+        let r;
+        if (hasCrypto && randomBytes) {
+            // Each byte gives two hex digits (nibbles)
+            r = i % 2 === 0 ? randomBytes[byteIndex] >> 4 : randomBytes[byteIndex++] & 0x0f;
+        } else {
+            r = Math.floor(Math.random() * 16);
+        }
+        if (c === 'x') {
+            uuid += HEX_CHARS[r];
+        } else if (c === 'y') {
+            // Variant bits: 8, 9, A, or B
+            uuid += HEX_CHARS[r & 0x3 | 0x8];
+        } else if (c === '4') {
+            uuid += '4';
+        }
+    }
+    return uuid;
+};
+
+
+},
+
+});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  TracingCapability: () => (/* reexport */ TracingCapability),
+  Capability: () => (/* reexport */ Capability),
+  PerformanceCapability: () => (/* reexport */ PerformanceCapability)
+});
+
+;// CONCATENATED MODULE: ./src/capabilities/Capability.ts
+class Capability {
+    excludedNames = new Set([
+        "Array",
+        "Set",
+        "Map",
+        "AbortController",
+        "AbortSignal",
+        "SchemaString",
+        "SchemaNumber",
+        "SchemaArray",
+        "SchemaBoolean",
+        "SchemaDate",
+        "SchemaObject",
+        "SchemaDefault",
+        "SchemaDeserialize",
+        "SchemaDistinct",
+        "SchemaSearchable",
+        "SchemaFrom",
+        "SchemaIdentity",
+        "SchemaIndex",
+        "SchemaKey",
+        "SchemaNullable",
+        "SchemaOptional",
+        "SchemaReadonly",
+        "SchemaSerialize",
+        "SchemaTracked",
+        "SchemaComputed",
+        "SchemaFunction",
+        "SchemaBase",
+        "SchemaDefinition"
+    ]);
+    isValidObject(obj) {
+        return typeof obj === "object" && obj !== null;
+    }
+    isCallableMethod(descriptor, key) {
+        return descriptor?.value && typeof descriptor.value === 'function' && key !== 'constructor' && key !== 'undefined';
+    }
+    canExplore(descriptor) {
+        if (typeof descriptor.value !== "object") {
+            return false;
+        }
+        if (descriptor.value == null) {
+            return false;
+        }
+        const name = this.getName(descriptor.value);
+        if (name == null) {
+            return true;
+        }
+        return this.excludedNames.has(name) === false;
+    }
+    getName(value) {
+        if (value.constructor != null) {
+            return value.constructor.name;
+        }
+        return null;
+    }
+    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(".");
+    }
+    explore(instance, onDiscover) {
+        if (!this.isValidObject(instance)) {
+            return;
+        }
+        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);
+        }
+    }
+}
+
+// EXTERNAL MODULE: ./src/utilities/strings.ts
+var strings = __webpack_require__(615);
+;// CONCATENATED MODULE: ./src/capabilities/performance/PerformanceTracker.ts
+class PerformanceTracker {
+    methodTimings = new Map();
+    operationStartTimes = new Map();
+    startMethodTiming(operationId, methodPath) {
+        const startTime = performance.now();
+        const key = `${operationId}:${methodPath}`;
+        // Track operation start time for delta calculations
+        if (!this.operationStartTimes.has(operationId)) {
+            this.operationStartTimes.set(operationId, startTime);
+        }
+        this.methodTimings.set(key, {
+            startTime
+        });
+        return startTime;
+    }
+    recordNextMethodStart(operationId, methodPath) {
+        const key = `${operationId}:${methodPath}`;
+        const timing = this.methodTimings.get(key);
+        if (timing) {
+            timing.nextMethodStartTime = performance.now();
+        }
+    }
+    endMethodTiming(operationId, methodPath) {
+        const endTime = performance.now();
+        const key = `${operationId}:${methodPath}`;
+        const timing = this.methodTimings.get(key);
+        if (!timing) {
+            return {
+                startTime: endTime
+            };
+        }
+        const duration = endTime - timing.startTime;
+        const timeToNextCall = timing.nextMethodStartTime ? timing.nextMethodStartTime - timing.startTime : undefined;
+        // Clean up
+        this.methodTimings.delete(key);
+        return {
+            startTime: timing.startTime,
+            endTime,
+            duration,
+            nextMethodStartTime: timing.nextMethodStartTime,
+            timeToNextCall
+        };
+    }
+    formatDuration(milliseconds) {
+        if (milliseconds < 1) {
+            return `${(milliseconds * 1000).toFixed(1)}μs`;
+        } else if (milliseconds < 1000) {
+            return `${milliseconds.toFixed(2)}ms`;
+        } else {
+            return `${(milliseconds / 1000).toFixed(2)}s`;
+        }
+    }
+    getDeltaFromOperationStart(operationId, currentTime) {
+        const operationStartTime = this.operationStartTimes.get(operationId);
+        return operationStartTime ? currentTime - operationStartTime : 0;
+    }
+    cleanupOperation(operationId) {
+        this.operationStartTimes.delete(operationId);
+    }
+}
+
+// EXTERNAL MODULE: ./src/utilities/uuid.ts
+var uuid = __webpack_require__(618);
+;// CONCATENATED MODULE: ./src/capabilities/tracing/CallTraceManager.ts
+
+class CallTraceManager {
+    activeOperationId = null;
+    activeCallStack = [];
+    startNewOperation() {
+        const operationId = (0,uuid/* .uuid */.u)(8);
+        this.activeOperationId = operationId;
+        this.activeCallStack = [];
+        return operationId;
+    }
+    isNewOperation() {
+        return this.activeOperationId === null;
+    }
+    getActiveOperationId() {
+        if (!this.activeOperationId) {
+            throw new Error('No active operation context');
+        }
+        return this.activeOperationId;
+    }
+    addMethodToTrace(methodPath) {
+        if (this.isNewOperation()) {
+            this.activeCallStack = [
+                methodPath
+            ];
+        } else {
+            this.activeCallStack.push(methodPath);
+        }
+        return [
+            ...this.activeCallStack
+        ];
+    }
+    removeMethodFromTrace() {
+        if (!this.isNewOperation()) {
+            this.activeCallStack.pop();
+        }
+    }
+    endOperation() {
+        this.activeOperationId = null;
+        this.activeCallStack = [];
+    }
+    formatMethodPaths(methodPaths) {
+        return methodPaths.map((path)=>path.replace(/ → /g, '.'));
+    }
+    getCurrentTrace() {
+        return [
+            ...this.activeCallStack
+        ];
+    }
+}
+
+// EXTERNAL MODULE: ./src/utilities/logger.ts
+var logger = __webpack_require__(581);
+;// CONCATENATED MODULE: ./src/capabilities/PerformanceCapability.ts
+
+
+
+
+
+class PerformanceCapability extends Capability {
+    callTraceManager;
+    performanceTracker;
+    filter;
+    childDurations = new Map();
+    constructor(options){
+        super();
+        this.filter = options?.filter ?? (()=>true);
+        this.callTraceManager = new CallTraceManager();
+        this.performanceTracker = new PerformanceTracker();
+    }
+    apply(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);
+                        logger/* .logger.log */.vF.log(`\n${'═'.repeat(60)}`);
+                        logger/* .logger.log */.vF.log(`▶ ORIGIN [${operationId}] ${path}`);
+                        if (args.length > 0) {
+                            logger/* .logger.log */.vF.log(`  Args:`, (0,strings/* .stringifyObject */.Zm)(args, 4, 0));
+                        }
+                        logger/* .logger.log */.vF.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);
+                        logger/* .logger.log */.vF.log(`${indent}└─ CHILD [${operationId}] ${path}`);
+                        if (args.length > 0) {
+                            logger/* .logger.log */.vF.log(`${indent}   Args:`, (0,strings/* .stringifyObject */.Zm)(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));
+                            logger/* .logger.log */.vF.log(`\n${'═'.repeat(60)}`);
+                            logger/* .logger.log */.vF.log(`◀ COMPLETE [${operationId}] ${path}`);
+                            logger/* .logger.log */.vF.log(`  Total Duration: ${formattedDuration}`);
+                            if (childDurations.length > 0) {
+                                logger/* .logger.log */.vF.log(`  Children Duration: ${formattedTotalChildTime} (${childDurations.length} calls)`);
+                                logger/* .logger.log */.vF.log(`  Overhead: ${formattedOverhead}`);
+                            }
+                            logger/* .logger.log */.vF.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));
+                            logger/* .logger.log */.vF.log(`${indent}   ✓ ${formattedDuration}`);
+                            if (childDurations.length > 0) {
+                                logger/* .logger.log */.vF.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();
+                    }
+                };
+            }
+        });
+    }
+}
+
+;// CONCATENATED MODULE: ./src/capabilities/TracingCapability.ts
+
+
+
+class TracingCapability extends Capability {
+    callTraceManager;
+    filter;
+    constructor(options){
+        super();
+        this.filter = options?.filter ?? (()=>true);
+        this.callTraceManager = new CallTraceManager();
+    }
+    apply(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;
+                    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,strings/* .stringifyObject */.Zm)(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,strings/* .stringifyObject */.Zm)(args, 4, 0));
+                        }
+                    }
+                    try {
+                        return originalMethod(...args);
+                    } finally{
+                        this.callTraceManager.removeMethodFromTrace();
+                        if (isNewOperation) {
+                            this.callTraceManager.endOperation();
+                        }
+                    }
+                };
+            }
+        });
+    }
+}
+
+;// CONCATENATED MODULE: ./src/capabilities/index.ts
+
+
+
+
+
+})();
+
+module.exports = __webpack_exports__;
+})()
+;
+//# sourceMappingURL=index.cjs.map