0xray 3.0.12 → 3.1.0

package/dist/analytics/simple-pattern-analyzer.js

@@ -0,0 +1,297 @@
+/**
+ * Simple Pattern Analyzer for 0xRay
+ *
+ * Reads activity log → Counts patterns → Generates insights
+ *
+ * This is the "learning" system - simple pattern matching, not ML.
+ *
+ * @version 1.0.0
+ */
+import * as fs from "fs";
+import * as path from "path";
+export class SimplePatternAnalyzer {
+    logPath;
+    outcomesPath;
+    constructor(logPath) {
+        const cwd = process.cwd();
+        this.logPath =
+            logPath || path.join(cwd, "logs", "framework", "activity.log");
+        // Only use outcomes path when using default log path
+        this.outcomesPath = logPath ? "" : path.join(cwd, "logs", "framework", "routing-outcomes.json");
+    }
+    /**
+     * Main analysis method - reads log and returns insights
+     */
+    async analyze(limit) {
+        const entries = [];
+        // Try to read from routing-outcomes.json first (has more complete data)
+        // Only when using default paths
+        if (this.outcomesPath && fs.existsSync(this.outcomesPath)) {
+            try {
+                const outcomes = JSON.parse(fs.readFileSync(this.outcomesPath, "utf-8"));
+                const outcomesToAnalyze = limit ? outcomes.slice(-limit) : outcomes;
+                for (const outcome of outcomesToAnalyze) {
+                    entries.push({
+                        timestamp: outcome.timestamp || new Date().toISOString(),
+                        jobId: outcome.taskId || "",
+                        component: outcome.routedAgent || "unknown",
+                        action: "routing-outcome",
+                        status: outcome.success ? "success" : "error",
+                        agentUsed: outcome.routedAgent,
+                        operationType: outcome.routedSkill,
+                        outcome: outcome.success ? "success" : "fail",
+                        complexityScore: outcome.complexity,
+                    });
+                }
+            }
+            catch {
+                // Fall back to activity log parsing
+            }
+        }
+        // Fall back to activity log parsing if no outcomes
+        if (entries.length === 0 && fs.existsSync(this.logPath)) {
+            const content = fs.readFileSync(this.logPath, "utf-8");
+            const lines = content.split("\n").filter((l) => l.trim());
+            // Filter to task completion entries
+            const completionLines = lines.filter((line) => line.includes("complex-task-completed") ||
+                line.includes("job-completed") ||
+                line.includes("task-completed"));
+            const entriesToAnalyze = limit ? completionLines.slice(-limit) : completionLines;
+            const parsedEntries = entriesToAnalyze
+                .map((line) => this.parseLine(line))
+                .filter((e) => e !== null);
+            entries.push(...parsedEntries);
+        }
+        if (entries.length === 0) {
+            return this.emptyInsights();
+        }
+        return this.calculateStats(entries);
+    }
+    /**
+     * Parse a single log line
+     */
+    parseLine(line) {
+        // Format: 2026-02-24T10:30:00.000Z [job-123-abc] [component] action - STATUS | {"details": "..."}
+        const match = line.match(/^(\d{4}-\d{2}-\d{2}T[\d:.]+Z)\s+\[([^\]]+)\]\s+\[([^\]]+)\]\s+(.+?)\s+-\s+(\w+)(?:\s*\|\s*(.+))?$/);
+        if (!match) {
+            return null;
+        }
+        const [, timestamp, jobId, component, actionRaw, statusRaw, detailsRaw] = match;
+        // Parse action and any embedded details
+        const action = actionRaw?.trim() || "unknown";
+        const status = statusRaw?.toLowerCase() || "info";
+        // Parse JSON details if present
+        let details = {};
+        if (detailsRaw) {
+            try {
+                details = JSON.parse(detailsRaw.trim());
+            }
+            catch {
+                // Not JSON, ignore
+            }
+        }
+        return {
+            timestamp: timestamp || "",
+            jobId: jobId || "",
+            component: component || "unknown",
+            action,
+            status,
+            duration: details.duration,
+            complexityScore: details.complexityScore,
+            agentUsed: details.agentUsed || details.agent || details.taskType,
+            operationType: details.operationType || details.taskType,
+            outcome: details.outcome,
+            complexityAccuracy: details.complexityAccuracy,
+        };
+    }
+    /**
+     * Calculate statistics from parsed entries
+     */
+    calculateStats(entries) {
+        const agentStats = new Map();
+        const taskTypeStats = new Map();
+        const complexityStats = {
+            underestimated: 0,
+            accurate: 0,
+            overestimated: 0,
+            total: 0,
+        };
+        // Filter to entries with analytics data (task completions or routing outcomes)
+        const relevantEntries = entries.filter((e) => e.action === "job-completed" ||
+            e.action === "routing-outcome" ||
+            e.action.includes("completed") ||
+            e.outcome !== undefined);
+        for (const entry of relevantEntries) {
+            const agent = entry.agentUsed || entry.component || "unknown";
+            // Agent stats
+            if (!agentStats.has(agent)) {
+                agentStats.set(agent, {
+                    attempts: 0,
+                    successes: 0,
+                    failures: 0,
+                    escalated: 0,
+                    autoFixed: 0,
+                    avgDuration: 0,
+                    totalDuration: 0,
+                });
+            }
+            const stats = agentStats.get(agent);
+            stats.attempts++;
+            if (entry.duration) {
+                stats.totalDuration += entry.duration;
+                stats.avgDuration = stats.totalDuration / stats.attempts;
+            }
+            // Outcome tracking
+            const outcome = entry.outcome || (entry.status === "success" ? "success" : "fail");
+            switch (outcome) {
+                case "success":
+                    stats.successes++;
+                    break;
+                case "fail":
+                    stats.failures++;
+                    break;
+                case "escalated":
+                    stats.escalated++;
+                    break;
+                case "auto-fixed":
+                    stats.autoFixed++;
+                    break;
+            }
+            // Task type stats
+            const taskType = entry.operationType || "unknown";
+            if (!taskTypeStats.has(taskType)) {
+                taskTypeStats.set(taskType, {
+                    count: 0,
+                    successRate: 0,
+                    avgComplexity: 0,
+                });
+            }
+            const taskStat = taskTypeStats.get(taskType);
+            taskStat.count++;
+            if (entry.complexityScore) {
+                taskStat.avgComplexity =
+                    (taskStat.avgComplexity * (taskStat.count - 1) +
+                        entry.complexityScore) /
+                        taskStat.count;
+            }
+            // Complexity accuracy
+            if (entry.complexityAccuracy) {
+                complexityStats.total++;
+                switch (entry.complexityAccuracy) {
+                    case "underestimated":
+                        complexityStats.underestimated++;
+                        break;
+                    case "accurate":
+                        complexityStats.accurate++;
+                        break;
+                    case "overestimated":
+                        complexityStats.overestimated++;
+                        break;
+                }
+            }
+        }
+        // Calculate success rates
+        for (const [agent, stats] of agentStats) {
+            if (stats.attempts > 0) {
+                // We'll calculate in the output
+            }
+        }
+        for (const [taskType, stats] of taskTypeStats) {
+            const agentStatsForTask = Array.from(agentStats.values()).reduce((acc, s) => ({
+                attempts: acc.attempts + s.attempts,
+                successes: acc.successes + s.successes,
+            }), { attempts: 0, successes: 0 });
+            stats.successRate =
+                agentStatsForTask.attempts > 0
+                    ? (agentStatsForTask.successes / agentStatsForTask.attempts) * 100
+                    : 0;
+        }
+        const sortedEntries = [...entries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+        return {
+            agentStats,
+            taskTypeStats,
+            complexityStats,
+            totalEntries: entries.length,
+            dateRange: {
+                start: sortedEntries[0]?.timestamp || "",
+                end: sortedEntries[sortedEntries.length - 1]?.timestamp || "",
+            },
+        };
+    }
+    /**
+     * Generate human-readable insights
+     */
+    generateInsights(insights) {
+        const output = [];
+        if (insights.totalEntries === 0) {
+            return ["No activity log entries found."];
+        }
+        // Agent performance
+        output.push("=== Agent Performance ===");
+        for (const [agent, stats] of insights.agentStats) {
+            const successRate = stats.attempts > 0
+                ? ((stats.successes / stats.attempts) * 100).toFixed(1)
+                : "0.0";
+            const avgDuration = stats.avgDuration > 0
+                ? (stats.avgDuration / 1000).toFixed(1) + "s"
+                : "N/A";
+            output.push(`- ${agent}: ${successRate}% success (${stats.attempts} tasks), avg ${avgDuration}`);
+        }
+        // Complexity accuracy
+        output.push("");
+        output.push("=== Complexity Accuracy ===");
+        const { underestimated, accurate, overestimated, total } = insights.complexityStats;
+        if (total > 0) {
+            output.push(`- Underestimated: ${((underestimated / total) * 100).toFixed(1)}% (tasks took longer than predicted)`);
+            output.push(`- Accurate: ${((accurate / total) * 100).toFixed(1)}% (predictions within 50%)`);
+            output.push(`- Overestimated: ${((overestimated / total) * 100).toFixed(1)}% (tasks completed faster than predicted)`);
+        }
+        else {
+            output.push("- Not enough data to determine accuracy");
+        }
+        // Task type breakdown
+        output.push("");
+        output.push("=== Task Types ===");
+        for (const [taskType, stats] of insights.taskTypeStats) {
+            output.push(`- ${taskType}: ${stats.count} tasks, avg complexity ${stats.avgComplexity.toFixed(0)}`);
+        }
+        return output;
+    }
+    /**
+     * Generate insights as a formatted report
+     */
+    async generateReport() {
+        const insights = await this.analyze();
+        const insightsLines = this.generateInsights(insights);
+        const report = [
+            "╔════════════════════════════════════════════════════════════╗",
+            "║           0xRay Pattern Analytics Report             ║",
+            "╚════════════════════════════════════════════════════════════╝",
+            "",
+            `Analyzed: ${insights.totalEntries} log entries`,
+            `Date Range: ${insights.dateRange.start || "N/A"} to ${insights.dateRange.end || "N/A"}`,
+            "",
+            ...insightsLines,
+            "",
+            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+            "Generated by 0xRay Simple Pattern Analyzer",
+        ];
+        return report.join("\n");
+    }
+    emptyInsights() {
+        return {
+            agentStats: new Map(),
+            taskTypeStats: new Map(),
+            complexityStats: {
+                underestimated: 0,
+                accurate: 0,
+                overestimated: 0,
+                total: 0,
+            },
+            totalEntries: 0,
+            dateRange: { start: "", end: "" },
+        };
+    }
+}
+// Export singleton for easy use
+export const patternAnalyzer = new SimplePatternAnalyzer();

package/dist/architect/architect-tools.js

@@ -435,4 +435,3 @@ export const architectTools = {
     dependencyAnalysis,
     architectureAssessment,
 };
-//# sourceMappingURL=architect-tools.js.map

package/dist/architect/architectural-integrity.js

@@ -76,4 +76,3 @@ async function forceCodexActivation() {
     // Implementation to force codex activation
     // This ensures rules are always enforced
 }
-//# sourceMappingURL=architectural-integrity.js.map

package/dist/benchmark/performance-benchmark.js

@@ -0,0 +1,374 @@
+// Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray fallbacks)
+import { frameworkLogger } from "../core/framework-logger.js";
+import crypto from "crypto";
+export class XrayPerformanceBenchmark {
+    results = [];
+    activeBenchmarks = new Map();
+    /**
+     * Start a benchmark measurement
+     */
+    startBenchmark(operation, metadata = {}) {
+        const benchmarkId = `${operation}_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
+        this.activeBenchmarks.set(benchmarkId, {
+            startTime: performance.now(),
+            metadata,
+        });
+        return benchmarkId;
+    }
+    /**
+     * End a benchmark measurement
+     */
+    endBenchmark(benchmarkId, success = true, error) {
+        const activeBenchmark = this.activeBenchmarks.get(benchmarkId);
+        if (!activeBenchmark) {
+            frameworkLogger.log("performance-benchmark", "benchmark-not-found", "warning", { benchmarkId });
+            return null;
+        }
+        const endTime = performance.now();
+        const duration = endTime - activeBenchmark.startTime;
+        const result = {
+            operation: benchmarkId.split("_")[0] || "unknown",
+            startTime: activeBenchmark.startTime,
+            endTime,
+            duration,
+            success,
+            metadata: activeBenchmark.metadata,
+            error,
+        };
+        this.results.push(result);
+        this.activeBenchmarks.delete(benchmarkId);
+        return result;
+    }
+    /**
+     * Benchmark boot sequence performance
+     */
+    async benchmarkBootSequence(_bootOrchestrator) {
+        const result = {
+            totalBootTime: 0,
+            phaseTimings: {},
+            componentLoadTimes: {},
+            memoryUsage: {
+                beforeBoot: 0,
+                afterBoot: 0,
+                peakDuringBoot: 0,
+            },
+            success: false,
+            errors: [],
+        };
+        const bootStartTime = performance.now();
+        const peakMemory = 0;
+        try {
+            // Measure initial memory
+            result.memoryUsage.beforeBoot = process.memoryUsage().heapUsed;
+            // Phase 1: Orchestrator loading
+            const orchestratorStart = performance.now();
+            const benchmarkId = this.startBenchmark("orchestrator_load");
+            // Boot sequence will be executed by the caller
+            const orchestratorResult = this.endBenchmark(benchmarkId, true);
+            if (orchestratorResult) {
+                result.phaseTimings.orchestrator_load = orchestratorResult.duration;
+                result.componentLoadTimes.orchestrator = orchestratorResult.duration;
+            }
+            // Phase 2: Delegation system initialization
+            const delegationStart = performance.now();
+            const delegationBenchmarkId = this.startBenchmark("delegation_init");
+            // This will be measured during actual boot
+            const delegationResult = this.endBenchmark(delegationBenchmarkId, true);
+            if (delegationResult) {
+                result.phaseTimings.delegation_init = delegationResult.duration;
+                result.componentLoadTimes.delegation_system = delegationResult.duration;
+            }
+            // Phase 3: Session management initialization
+            const sessionStart = performance.now();
+            const sessionBenchmarkId = this.startBenchmark("session_management_init");
+            const sessionResult = this.endBenchmark(sessionBenchmarkId, true);
+            if (sessionResult) {
+                result.phaseTimings.session_management_init = sessionResult.duration;
+                result.componentLoadTimes.session_management = sessionResult.duration;
+            }
+            // Phase 4: Processor activation
+            const processorStart = performance.now();
+            const processorBenchmarkId = this.startBenchmark("processor_activation");
+            const processorResult = this.endBenchmark(processorBenchmarkId, true);
+            if (processorResult) {
+                result.phaseTimings.processor_activation = processorResult.duration;
+                result.componentLoadTimes.processor_pipeline = processorResult.duration;
+            }
+            // Phase 5: Agent loading
+            const agentStart = performance.now();
+            const agentBenchmarkId = this.startBenchmark("agent_loading");
+            const agentResult = this.endBenchmark(agentBenchmarkId, true);
+            if (agentResult) {
+                result.phaseTimings.agent_loading = agentResult.duration;
+                result.componentLoadTimes.agent_loading = agentResult.duration;
+            }
+            // Phase 6: Enforcement activation
+            const enforcementStart = performance.now();
+            const enforcementBenchmarkId = this.startBenchmark("enforcement_activation");
+            const enforcementResult = this.endBenchmark(enforcementBenchmarkId, true);
+            if (enforcementResult) {
+                result.phaseTimings.enforcement_activation = enforcementResult.duration;
+                result.componentLoadTimes.enforcement_system =
+                    enforcementResult.duration;
+            }
+            // Phase 7: Codex compliance activation
+            const codexStart = performance.now();
+            const codexBenchmarkId = this.startBenchmark("codex_compliance_activation");
+            const codexResult = this.endBenchmark(codexBenchmarkId, true);
+            if (codexResult) {
+                result.phaseTimings.codex_compliance_activation = codexResult.duration;
+                result.componentLoadTimes.codex_compliance = codexResult.duration;
+            }
+            // Calculate total boot time
+            result.totalBootTime = performance.now() - bootStartTime;
+            result.memoryUsage.afterBoot = process.memoryUsage().heapUsed;
+            result.memoryUsage.peakDuringBoot = peakMemory;
+            result.success = true;
+        }
+        catch (error) {
+            result.errors.push(error instanceof Error ? error.message : String(error));
+            result.success = false;
+        }
+        return result;
+    }
+    /**
+     * Benchmark orchestrator task execution
+     */
+    async benchmarkOrchestratorTasks(_orchestrator, taskCount = 10, concurrentTasks = 3) {
+        const result = {
+            taskExecutionTimes: [],
+            delegationLatencies: [],
+            conflictResolutionTimes: [],
+            concurrentTaskThroughput: 0,
+            dependencyResolutionTime: 0,
+            overallSuccess: true,
+        };
+        try {
+            // Benchmark single task execution
+            for (let i = 0; i < taskCount; i++) {
+                const taskStart = performance.now();
+                const benchmarkId = this.startBenchmark(`single_task_${i}`, {
+                    taskId: `task_${i}`,
+                });
+                // Simulate task execution
+                await new Promise((resolve) => setTimeout(resolve, Math.random() * 100 + 50));
+                const taskResult = this.endBenchmark(benchmarkId, true);
+                if (taskResult) {
+                    result.taskExecutionTimes.push(taskResult.duration);
+                }
+            }
+            // Benchmark concurrent task execution
+            const concurrentStart = performance.now();
+            const concurrentPromises = [];
+            for (let i = 0; i < concurrentTasks; i++) {
+                const benchmarkId = this.startBenchmark(`concurrent_task_${i}`, {
+                    concurrent: true,
+                });
+                const promise = new Promise((resolve) => {
+                    setTimeout(() => {
+                        this.endBenchmark(benchmarkId, true);
+                        resolve();
+                    }, Math.random() * 200 + 100);
+                });
+                concurrentPromises.push(promise);
+            }
+            await Promise.all(concurrentPromises);
+            const concurrentEnd = performance.now();
+            result.concurrentTaskThroughput =
+                concurrentTasks / ((concurrentEnd - concurrentStart) / 1000);
+            // Benchmark complex task with dependencies
+            const dependencyStart = performance.now();
+            const dependencyBenchmarkId = this.startBenchmark("dependency_resolution");
+            const complexTasks = [
+                {
+                    id: "task_a",
+                    description: "Task A",
+                    subagentType: "architect",
+                    dependencies: [],
+                },
+                {
+                    id: "task_b",
+                    description: "Task B",
+                    subagentType: "code-reviewer",
+                    dependencies: ["task_a"],
+                },
+                {
+                    id: "task_c",
+                    description: "Task C",
+                    subagentType: "researcher",
+                    dependencies: ["task_b"],
+                },
+            ];
+            // Simulate dependency resolution
+            await new Promise((resolve) => setTimeout(resolve, 150));
+            const dependencyResult = this.endBenchmark(dependencyBenchmarkId, true);
+            if (dependencyResult) {
+                result.dependencyResolutionTime = dependencyResult.duration;
+            }
+        }
+        catch (error) {
+            result.overallSuccess = false;
+            await frameworkLogger.log("performance-benchmark", "orchestrator-benchmarking-failed", "error", { error: String(error) });
+        }
+        return result;
+    }
+    /**
+     * Benchmark session management operations
+     */
+    async benchmarkSessionOperations(_sessionStateManager, operationCount = 20) {
+        const result = {
+            stateShareLatencies: [],
+            dependencyUpdateTimes: [],
+            groupOperationTimes: [],
+            migrationTimes: [],
+            failoverTimes: [],
+            concurrentSessionOperations: 0,
+        };
+        try {
+            // Benchmark state sharing
+            for (let i = 0; i < operationCount; i++) {
+                const shareStart = performance.now();
+                const benchmarkId = this.startBenchmark(`state_share_${i}`, {
+                    operation: "share",
+                });
+                // Simulate state sharing
+                await new Promise((resolve) => setTimeout(resolve, Math.random() * 20 + 5));
+                const shareResult = this.endBenchmark(benchmarkId, true);
+                if (shareResult) {
+                    result.stateShareLatencies.push(shareResult.duration);
+                }
+            }
+            // Benchmark dependency operations
+            for (let i = 0; i < operationCount / 2; i++) {
+                const depStart = performance.now();
+                const benchmarkId = this.startBenchmark(`dependency_update_${i}`, {
+                    operation: "dependency",
+                });
+                // Simulate dependency update
+                await new Promise((resolve) => setTimeout(resolve, Math.random() * 30 + 10));
+                const depResult = this.endBenchmark(benchmarkId, true);
+                if (depResult) {
+                    result.dependencyUpdateTimes.push(depResult.duration);
+                }
+            }
+            // Benchmark group operations
+            const groupStart = performance.now();
+            const groupBenchmarkId = this.startBenchmark("group_operations", {
+                operation: "group",
+            });
+            // Simulate group operations
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            const groupResult = this.endBenchmark(groupBenchmarkId, true);
+            if (groupResult) {
+                result.groupOperationTimes.push(groupResult.duration);
+            }
+            // Benchmark migration simulation
+            const migrationStart = performance.now();
+            const migrationBenchmarkId = this.startBenchmark("session_migration", {
+                operation: "migration",
+            });
+            // Simulate migration
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            const migrationResult = this.endBenchmark(migrationBenchmarkId, true);
+            if (migrationResult) {
+                result.migrationTimes.push(migrationResult.duration);
+            }
+        }
+        catch (error) {
+            await frameworkLogger.log("performance-benchmark", "session-benchmarking-failed", "error", { error: String(error) });
+        }
+        return result;
+    }
+    /**
+     * Calculate performance metrics from benchmark results
+     */
+    calculateMetrics(operationFilter) {
+        const filteredResults = operationFilter
+            ? this.results.filter((r) => r.operation.includes(operationFilter))
+            : this.results;
+        if (filteredResults.length === 0) {
+            return {
+                totalOperations: 0,
+                successfulOperations: 0,
+                failedOperations: 0,
+                averageDuration: 0,
+                medianDuration: 0,
+                p95Duration: 0,
+                p99Duration: 0,
+                minDuration: 0,
+                maxDuration: 0,
+                throughput: 0,
+            };
+        }
+        const durations = filteredResults
+            .map((r) => r.duration)
+            .sort((a, b) => a - b);
+        const successful = filteredResults.filter((r) => r.success);
+        const totalTime = Math.max(...filteredResults.map((r) => r.endTime)) -
+            Math.min(...filteredResults.map((r) => r.startTime));
+        const avgDuration = durations.length > 0
+            ? durations.reduce((a, b) => a + b, 0) / durations.length
+            : 0;
+        const medianIndex = Math.floor(durations.length / 2);
+        const medianDuration = durations.length > 0 ? durations[medianIndex] : 0;
+        const p95Index = Math.floor(durations.length * 0.95);
+        const p95Duration = durations.length > 0 ? durations[p95Index] : 0;
+        const p99Index = Math.floor(durations.length * 0.99);
+        const p99Duration = durations.length > 0 ? durations[p99Index] : 0;
+        const minDuration = durations.length > 0 ? Math.min(...durations) : 0;
+        const maxDuration = durations.length > 0 ? Math.max(...durations) : 0;
+        return {
+            totalOperations: filteredResults.length,
+            successfulOperations: successful.length,
+            failedOperations: filteredResults.length - successful.length,
+            averageDuration: avgDuration,
+            medianDuration,
+            p95Duration,
+            p99Duration,
+            minDuration,
+            maxDuration,
+            throughput: filteredResults.length / (totalTime / 1000),
+        };
+    }
+    /**
+     * Generate comprehensive benchmark report
+     */
+    generateReport() {
+        const summary = this.calculateMetrics();
+        const report = {
+            summary,
+            recommendations: [],
+        };
+        // Analyze results and generate recommendations
+        if (summary.averageDuration > 100) {
+            report.recommendations.push("Consider optimizing slow operations (>100ms average)");
+        }
+        if (summary.failedOperations > 0) {
+            report.recommendations.push(`${summary.failedOperations} operations failed - investigate error patterns`);
+        }
+        if (summary.p95Duration > 500) {
+            report.recommendations.push("P95 latency >500ms - consider performance optimizations");
+        }
+        if (summary.throughput < 10) {
+            report.recommendations.push("Low throughput (<10 ops/sec) - evaluate bottlenecks");
+        }
+        return report;
+    }
+    /**
+     * Clear all benchmark results
+     */
+    clearResults() {
+        this.results = [];
+        this.activeBenchmarks.clear();
+    }
+    /**
+     * Export results for external analysis
+     */
+    exportResults() {
+        return [...this.results];
+    }
+}
+// Export singleton instance
+export const performanceBenchmark = new XrayPerformanceBenchmark();
+// Backward compat alias
+export { XrayPerformanceBenchmark as StringRayPerformanceBenchmark };