@routier/core 0.4.0 → 0.5.0

package/dist/index.cjs

@@ -101,436 +101,6 @@ function isObjectWithType(value) {
 }
 
 
-},
-599(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-
-// 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
-
-
-
-
-
-
 },
 980(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
@@ -3687,12 +3257,13 @@ var TrampolinePipeline = __webpack_require__(416);
 
 
 },
-301(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+454(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   DEFAULT_SEMI_JOIN_KEY_THRESHOLD: () => (/* reexport */ DEFAULT_SEMI_JOIN_KEY_THRESHOLD),
   TranslatedArrayValue: () => (/* reexport */ TranslatedArrayValue),
+  collectingSink: () => (/* reexport */ collectingSink),
   semiJoinFilter: () => (/* reexport */ semiJoinFilter),
   CacheDbPlugin: () => (/* reexport */ CacheDbPlugin),
   Query: () => (/* reexport */ Query),
@@ -3714,16 +3285,18 @@ __webpack_require__.d(__webpack_exports__, {
   EXECUTED_QUERIES_UNSUPPORTED: () => (/* reexport */ EXECUTED_QUERIES_UNSUPPORTED),
   joinInPlugin: () => (/* reexport */ joinInPlugin),
   deserializePersistResult: () => (/* reexport */ deserializePersistResult),
+  loggerSink: () => (/* reexport */ loggerSink),
   nearestBy: () => (/* reexport */ nearestBy),
   readJoinKey: () => (/* reexport */ readJoinKey),
-  serializeBulkPersist: () => (/* reexport */ serializeBulkPersist),
   hashJoin: () => (/* reexport */ hashJoin),
   EphemeralDataPlugin: () => (/* reexport */ EphemeralDataPlugin),
   QueryOptionsCollection: () => (/* reexport */ QueryOptionsCollection/* .QueryOptionsCollection */.H),
+  serializeBulkPersist: () => (/* reexport */ serializeBulkPersist),
   toEntityShape: () => (/* reexport */ toEntityShape),
   loadJoinInnerSide: () => (/* reexport */ loadJoinInnerSide),
   DataTranslator: () => (/* reexport */ DataTranslator),
   withExecutedQueries: () => (/* reexport */ withExecutedQueries),
+  TelemetryDbPlugin: () => (/* reexport */ TelemetryDbPlugin),
   createRequestHandler: () => (/* reexport */ createRequestHandler),
   SqlTranslator: () => (/* reexport */ SqlTranslator),
   QueryOrdering: () => (/* reexport */ types_QueryOrdering),
@@ -6714,6 +6287,69 @@ class RetryDbPlugin {
     }
 }
 
+;// CONCATENATED MODULE: ./src/plugins/TelemetryDbPlugin.ts
+
+/** Default sink: writes through the levelled logger, so ROUTIER_LOG_LEVEL governs it. */ const loggerSink = ()=>(e)=>{
+        const line = `[routier] ${e.operation} ${e.schemas.join(",")} ${e.durationMs.toFixed(1)}ms`;
+        if (e.ok === "error") {
+            logger/* .logger.error */.vF.error(line, e.error);
+            return;
+        }
+        logger/* .logger.info */.vF.info(line);
+    };
+/** Pushes every event into `into`. For tests and custom buffering. */ const collectingSink = (into)=>(e)=>{
+        into.push(e);
+    };
+class TelemetryDbPlugin {
+    plugin;
+    onEvent;
+    constructor(plugin, options = {}){
+        this.plugin = plugin;
+        this.onEvent = options.onEvent ?? loggerSink();
+    }
+    get databaseName() {
+        return this.plugin.databaseName;
+    }
+    query(event, done) {
+        const start = performance.now();
+        this.plugin.query(event, (result)=>{
+            this.emit("query", event, result, start);
+            done(result);
+        });
+    }
+    bulkPersist(event, done) {
+        const start = performance.now();
+        this.plugin.bulkPersist(event, (result)=>{
+            this.emit("bulkPersist", event, result, start);
+            done(result);
+        });
+    }
+    destroy(event, done) {
+        const start = performance.now();
+        this.plugin.destroy(event, (result)=>{
+            this.emit("destroy", event, result, start);
+            done(result);
+        });
+    }
+    emit(operation, event, result, start) {
+        try {
+            this.onEvent({
+                operation,
+                eventId: event.id,
+                source: event.source,
+                schemas: [
+                    ...event.schemas.values()
+                ].map((s)=>s.collectionName),
+                durationMs: performance.now() - start,
+                ok: result.ok,
+                error: result.ok === "success" ? undefined : result.error
+            });
+        } catch  {
+        // A broken sink must never fail the data operation.
+        }
+    }
+}
+
 ;// CONCATENATED MODULE: ./src/plugins/CacheDbPlugin.ts
 
 /**
@@ -7178,6 +6814,7 @@ const DEFAULT_MAX_BATCH_SIZE = 100;
 
 
 
+
 },
 198(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
@@ -14183,7 +13820,6 @@ __webpack_require__.d(__webpack_exports__, {
   BulkPersistChanges: () => (/* reexport safe */ _collections__rspack_import_2.BulkPersistChanges),
   BulkPersistResult: () => (/* reexport safe */ _collections__rspack_import_2.BulkPersistResult),
   CacheDbPlugin: () => (/* reexport safe */ _plugins__rspack_import_7.CacheDbPlugin),
-  Capability: () => (/* reexport safe */ _capabilities__rspack_import_11.Capability),
   CodeBuilder: () => (/* reexport safe */ _codegen__rspack_import_1.CodeBuilder),
   ComparatorExpression: () => (/* reexport safe */ _expressions__rspack_import_4.ComparatorExpression),
   ConcurrencyDbPlugin: () => (/* reexport safe */ _plugins__rspack_import_7.ConcurrencyDbPlugin),
@@ -14208,7 +13844,6 @@ __webpack_require__.d(__webpack_exports__, {
   ObjectBuilder: () => (/* reexport safe */ _codegen__rspack_import_1.ObjectBuilder),
   OperatorExpression: () => (/* reexport safe */ _expressions__rspack_import_4.OperatorExpression),
   OptimisticConcurrencyError: () => (/* reexport safe */ _errors__rspack_import_3.OptimisticConcurrencyError),
-  PerformanceCapability: () => (/* reexport safe */ _capabilities__rspack_import_11.PerformanceCapability),
   PluginDestroyedError: () => (/* reexport safe */ _errors__rspack_import_3.PluginDestroyedError),
   PluginEventResult: () => (/* reexport safe */ _results__rspack_import_8.PluginEventResult),
   PropertyExpression: () => (/* reexport safe */ _expressions__rspack_import_4.PropertyExpression),
@@ -14258,7 +13893,7 @@ __webpack_require__.d(__webpack_exports__, {
   StringBuilder: () => (/* reexport safe */ _codegen__rspack_import_1.StringBuilder),
   SyncronousQueue: () => (/* reexport safe */ _pipeline__rspack_import_6.SyncronousQueue),
   TagCollection: () => (/* reexport safe */ _collections__rspack_import_2.TagCollection),
-  TracingCapability: () => (/* reexport safe */ _capabilities__rspack_import_11.TracingCapability),
+  TelemetryDbPlugin: () => (/* reexport safe */ _plugins__rspack_import_7.TelemetryDbPlugin),
   TrampolinePipeline: () => (/* reexport safe */ _pipeline__rspack_import_6.TrampolinePipeline),
   TranslatedArrayValue: () => (/* reexport safe */ _plugins__rspack_import_7.TranslatedArrayValue),
   TranslatedGroupValue: () => (/* reexport safe */ _plugins__rspack_import_7.TranslatedGroupValue),
@@ -14276,6 +13911,7 @@ __webpack_require__.d(__webpack_exports__, {
   assertString: () => (/* reexport safe */ _assertions__rspack_import_0.assertString),
   cast: () => (/* reexport safe */ _utilities__rspack_import_10.cast),
   clone: () => (/* reexport safe */ _utilities__rspack_import_10.clone),
+  collectingSink: () => (/* reexport safe */ _plugins__rspack_import_7.collectingSink),
   combineExpressions: () => (/* reexport safe */ _expressions__rspack_import_4.combineExpressions),
   combineQueryOptionsCollections: () => (/* reexport safe */ _utilities__rspack_import_10.combineQueryOptionsCollections),
   compiledSchemaToJsonSchema: () => (/* reexport safe */ _schema__rspack_import_9.compiledSchemaToJsonSchema),
@@ -14312,6 +13948,7 @@ __webpack_require__.d(__webpack_exports__, {
   joinInPlugin: () => (/* reexport safe */ _plugins__rspack_import_7.joinInPlugin),
   loadJoinInnerSide: () => (/* reexport safe */ _plugins__rspack_import_7.loadJoinInnerSide),
   logger: () => (/* reexport safe */ _utilities__rspack_import_10.logger),
+  loggerSink: () => (/* reexport safe */ _plugins__rspack_import_7.loggerSink),
   measure: () => (/* reexport safe */ _performance__rspack_import_5.measure),
   nearestBy: () => (/* reexport safe */ _plugins__rspack_import_7.nearestBy),
   noop: () => (/* reexport safe */ _utilities__rspack_import_10.noop),
@@ -14350,12 +13987,10 @@ __webpack_require__.d(__webpack_exports__, {
 /* import */ var _expressions__rspack_import_4 = __webpack_require__(138);
 /* import */ var _performance__rspack_import_5 = __webpack_require__(971);
 /* import */ var _pipeline__rspack_import_6 = __webpack_require__(314);
-/* import */ var _plugins__rspack_import_7 = __webpack_require__(301);
+/* import */ var _plugins__rspack_import_7 = __webpack_require__(454);
 /* import */ var _results__rspack_import_8 = __webpack_require__(264);
 /* import */ var _schema__rspack_import_9 = __webpack_require__(755);
 /* import */ var _utilities__rspack_import_10 = __webpack_require__(222);
-/* import */ var _capabilities__rspack_import_11 = __webpack_require__(599);
-