@routier/core 0.4.0 → 0.5.0

package/dist/capabilities/index.js

@@ -1,808 +0,0 @@
-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))
-})();
-var __webpack_exports__ = {};
-// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
-(() => {
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  nS: () => (/* reexport */ Capability),
-  VP: () => (/* reexport */ PerformanceCapability),
-  XO: () => (/* reexport */ TracingCapability)
-});
-
-;// 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
-
-
-
-
-
-})();
-
-var __webpack_exports__Capability = __webpack_exports__.nS;
-var __webpack_exports__PerformanceCapability = __webpack_exports__.VP;
-var __webpack_exports__TracingCapability = __webpack_exports__.XO;
-export { __webpack_exports__Capability as Capability, __webpack_exports__PerformanceCapability as PerformanceCapability, __webpack_exports__TracingCapability as TracingCapability };
-
-//# sourceMappingURL=index.js.map