ruvector 0.2.23 → 0.2.25

package/dist/core/cluster-wrapper.js

@@ -0,0 +1,271 @@
+"use strict";
+/**
+ * Cluster Wrapper - Distributed coordination for multi-agent systems
+ *
+ * Wraps @ruvector/cluster for Raft consensus, auto-sharding,
+ * and distributed memory across agents.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuvectorCluster = void 0;
+exports.isClusterAvailable = isClusterAvailable;
+exports.createCluster = createCluster;
+let clusterModule = null;
+let loadError = null;
+function getClusterModule() {
+    if (clusterModule)
+        return clusterModule;
+    if (loadError)
+        throw loadError;
+    try {
+        clusterModule = require('@ruvector/cluster');
+        return clusterModule;
+    }
+    catch (e) {
+        loadError = new Error(`@ruvector/cluster not installed: ${e.message}\n` +
+            `Install with: npm install @ruvector/cluster`);
+        throw loadError;
+    }
+}
+function isClusterAvailable() {
+    try {
+        getClusterModule();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Distributed cluster for multi-agent coordination
+ */
+class RuvectorCluster {
+    constructor(config) {
+        this.isLeader = false;
+        const cluster = getClusterModule();
+        this.nodeId = config.nodeId;
+        this.inner = new cluster.Cluster({
+            nodeId: config.nodeId,
+            address: config.address,
+            peers: config.peers ?? [],
+            shards: config.shards ?? 16,
+            replicationFactor: config.replicationFactor ?? 2,
+        });
+    }
+    // ===========================================================================
+    // Cluster Lifecycle
+    // ===========================================================================
+    /**
+     * Start the cluster node
+     */
+    async start() {
+        await this.inner.start();
+    }
+    /**
+     * Stop the cluster node gracefully
+     */
+    async stop() {
+        await this.inner.stop();
+    }
+    /**
+     * Join an existing cluster
+     */
+    async join(peerAddress) {
+        return this.inner.join(peerAddress);
+    }
+    /**
+     * Leave the cluster
+     */
+    async leave() {
+        await this.inner.leave();
+    }
+    // ===========================================================================
+    // Node Management
+    // ===========================================================================
+    /**
+     * Get current node info
+     */
+    getNodeInfo() {
+        return this.inner.getNodeInfo();
+    }
+    /**
+     * Get all cluster nodes
+     */
+    getNodes() {
+        return this.inner.getNodes();
+    }
+    /**
+     * Check if this node is the leader
+     */
+    isClusterLeader() {
+        this.isLeader = this.inner.isLeader();
+        return this.isLeader;
+    }
+    /**
+     * Get the current leader
+     */
+    getLeader() {
+        return this.inner.getLeader();
+    }
+    // ===========================================================================
+    // Distributed Operations
+    // ===========================================================================
+    /**
+     * Put a value in distributed storage
+     */
+    async put(key, value) {
+        return this.inner.put(key, JSON.stringify(value));
+    }
+    /**
+     * Get a value from distributed storage
+     */
+    async get(key) {
+        const result = await this.inner.get(key);
+        return result ? JSON.parse(result) : null;
+    }
+    /**
+     * Delete a value from distributed storage
+     */
+    async delete(key) {
+        return this.inner.delete(key);
+    }
+    /**
+     * Atomic compare-and-swap
+     */
+    async compareAndSwap(key, expected, newValue) {
+        return this.inner.compareAndSwap(key, JSON.stringify(expected), JSON.stringify(newValue));
+    }
+    // ===========================================================================
+    // Sharding
+    // ===========================================================================
+    /**
+     * Get shard information
+     */
+    getShards() {
+        return this.inner.getShards();
+    }
+    /**
+     * Get the shard for a key
+     */
+    getShardForKey(key) {
+        return this.inner.getShardForKey(key);
+    }
+    /**
+     * Trigger shard rebalancing
+     */
+    async rebalance() {
+        await this.inner.rebalance();
+    }
+    // ===========================================================================
+    // Distributed Locks
+    // ===========================================================================
+    /**
+     * Acquire a distributed lock
+     */
+    async lock(name, timeout = 30000) {
+        return this.inner.lock(name, timeout);
+    }
+    /**
+     * Release a distributed lock
+     */
+    async unlock(name, token) {
+        return this.inner.unlock(name, token);
+    }
+    /**
+     * Extend a lock's TTL
+     */
+    async extendLock(name, token, extension = 30000) {
+        return this.inner.extendLock(name, token, extension);
+    }
+    // ===========================================================================
+    // Pub/Sub
+    // ===========================================================================
+    /**
+     * Subscribe to a channel
+     */
+    subscribe(channel, callback) {
+        return this.inner.subscribe(channel, (msg) => {
+            callback(JSON.parse(msg));
+        });
+    }
+    /**
+     * Publish to a channel
+     */
+    async publish(channel, message) {
+        return this.inner.publish(channel, JSON.stringify(message));
+    }
+    // ===========================================================================
+    // Agent Coordination
+    // ===========================================================================
+    /**
+     * Register an agent with the cluster
+     */
+    async registerAgent(agentId, capabilities) {
+        return this.put(`agent:${agentId}`, {
+            id: agentId,
+            capabilities,
+            node: this.nodeId,
+            registeredAt: Date.now(),
+        });
+    }
+    /**
+     * Find agents with a capability
+     */
+    async findAgents(capability) {
+        const agents = await this.inner.scan('agent:*');
+        const matching = [];
+        for (const key of agents) {
+            const agent = await this.get(key);
+            if (agent?.capabilities?.includes(capability)) {
+                matching.push(agent.id);
+            }
+        }
+        return matching;
+    }
+    /**
+     * Assign a task to an agent
+     */
+    async assignTask(taskId, agentId, task) {
+        const assigned = await this.put(`task:${taskId}`, {
+            id: taskId,
+            agent: agentId,
+            task,
+            status: 'assigned',
+            assignedAt: Date.now(),
+        });
+        if (assigned) {
+            await this.publish(`agent:${agentId}:tasks`, { type: 'new_task', taskId });
+        }
+        return assigned;
+    }
+    /**
+     * Complete a task
+     */
+    async completeTask(taskId, result) {
+        const task = await this.get(`task:${taskId}`);
+        if (!task)
+            return false;
+        return this.put(`task:${taskId}`, {
+            ...task,
+            status: 'completed',
+            result,
+            completedAt: Date.now(),
+        });
+    }
+    // ===========================================================================
+    // Stats
+    // ===========================================================================
+    /**
+     * Get cluster statistics
+     */
+    stats() {
+        return this.inner.stats();
+    }
+}
+exports.RuvectorCluster = RuvectorCluster;
+/**
+ * Create a cluster node for agent coordination
+ */
+function createCluster(config) {
+    return new RuvectorCluster(config);
+}
+exports.default = RuvectorCluster;

package/dist/core/coverage-router.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Coverage Router - Test coverage-aware agent routing
+ *
+ * Uses test coverage data to make smarter routing decisions:
+ * - Prioritize testing for uncovered code
+ * - Route to tester agent for low-coverage files
+ * - Suggest test files for modified code
+ */
+export interface CoverageData {
+    file: string;
+    lines: {
+        total: number;
+        covered: number;
+        percentage: number;
+    };
+    functions: {
+        total: number;
+        covered: number;
+        percentage: number;
+    };
+    branches: {
+        total: number;
+        covered: number;
+        percentage: number;
+    };
+    uncoveredLines: number[];
+    uncoveredFunctions: string[];
+}
+export interface CoverageSummary {
+    files: Map<string, CoverageData>;
+    overall: {
+        lines: number;
+        functions: number;
+        branches: number;
+    };
+    lowCoverageFiles: string[];
+    uncoveredFiles: string[];
+}
+export interface TestSuggestion {
+    file: string;
+    testFile: string;
+    reason: string;
+    priority: 'high' | 'medium' | 'low';
+    coverage: number;
+    uncoveredFunctions: string[];
+}
+/**
+ * Parse Istanbul/NYC JSON coverage report
+ */
+export declare function parseIstanbulCoverage(coveragePath: string): CoverageSummary;
+/**
+ * Find coverage report in project
+ */
+export declare function findCoverageReport(projectRoot?: string): string | null;
+/**
+ * Get coverage data for a specific file
+ */
+export declare function getFileCoverage(file: string, summary?: CoverageSummary): CoverageData | null;
+/**
+ * Suggest tests for files based on coverage
+ */
+export declare function suggestTests(files: string[], summary?: CoverageSummary): TestSuggestion[];
+/**
+ * Determine if a file needs the tester agent based on coverage
+ */
+export declare function shouldRouteToTester(file: string, summary?: CoverageSummary): {
+    route: boolean;
+    reason: string;
+    coverage: number;
+};
+/**
+ * Get coverage-aware routing weight for agent selection
+ */
+export declare function getCoverageRoutingWeight(file: string, summary?: CoverageSummary): {
+    coder: number;
+    tester: number;
+    reviewer: number;
+};
+declare const _default: {
+    parseIstanbulCoverage: typeof parseIstanbulCoverage;
+    findCoverageReport: typeof findCoverageReport;
+    getFileCoverage: typeof getFileCoverage;
+    suggestTests: typeof suggestTests;
+    shouldRouteToTester: typeof shouldRouteToTester;
+    getCoverageRoutingWeight: typeof getCoverageRoutingWeight;
+};
+export default _default;
+//# sourceMappingURL=coverage-router.d.ts.map

package/dist/core/coverage-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage-router.d.ts","sourceRoot":"","sources":["../../src/core/coverage-router.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,SAAS,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,QAAQ,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACjC,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,eAAe,CA0F3E;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAiBrF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,YAAY,GAAG,IAAI,CAqB5F;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,cAAc,EAAE,CAwEzF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG;IAC5E,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAgCA;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG;IACjF,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAuBA;;;;;;;;;AAED,wBAOE"}

package/dist/core/coverage-router.js

@@ -0,0 +1,315 @@
+"use strict";
+/**
+ * Coverage Router - Test coverage-aware agent routing
+ *
+ * Uses test coverage data to make smarter routing decisions:
+ * - Prioritize testing for uncovered code
+ * - Route to tester agent for low-coverage files
+ * - Suggest test files for modified code
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIstanbulCoverage = parseIstanbulCoverage;
+exports.findCoverageReport = findCoverageReport;
+exports.getFileCoverage = getFileCoverage;
+exports.suggestTests = suggestTests;
+exports.shouldRouteToTester = shouldRouteToTester;
+exports.getCoverageRoutingWeight = getCoverageRoutingWeight;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Parse Istanbul/NYC JSON coverage report
+ */
+function parseIstanbulCoverage(coveragePath) {
+    const files = new Map();
+    const lowCoverageFiles = [];
+    const uncoveredFiles = [];
+    let totalLines = 0, coveredLines = 0;
+    let totalFunctions = 0, coveredFunctions = 0;
+    let totalBranches = 0, coveredBranches = 0;
+    try {
+        const coverage = JSON.parse(fs.readFileSync(coveragePath, 'utf8'));
+        for (const [file, data] of Object.entries(coverage)) {
+            // Skip test files
+            if (file.includes('.test.') || file.includes('.spec.') || file.includes('__tests__')) {
+                continue;
+            }
+            // Parse statement coverage
+            const statements = Object.values(data.s || {});
+            const linesCovered = statements.filter(n => n > 0).length;
+            const linesTotal = statements.length;
+            // Parse function coverage
+            const functions = Object.values(data.f || {});
+            const fnCovered = functions.filter(n => n > 0).length;
+            const fnTotal = functions.length;
+            // Parse branch coverage
+            const branches = Object.values(data.b || {}).flat();
+            const brCovered = branches.filter(n => n > 0).length;
+            const brTotal = branches.length;
+            // Find uncovered lines
+            const uncoveredLines = [];
+            for (const [line, count] of Object.entries(data.s || {})) {
+                if (count === 0) {
+                    uncoveredLines.push(parseInt(line));
+                }
+            }
+            // Find uncovered functions
+            const uncoveredFunctions = [];
+            const fnMap = data.fnMap || {};
+            for (const [fnId, count] of Object.entries(data.f || {})) {
+                if (count === 0 && fnMap[fnId]) {
+                    uncoveredFunctions.push(fnMap[fnId].name || `function_${fnId}`);
+                }
+            }
+            const linePercentage = linesTotal > 0 ? (linesCovered / linesTotal) * 100 : 100;
+            const fnPercentage = fnTotal > 0 ? (fnCovered / fnTotal) * 100 : 100;
+            const brPercentage = brTotal > 0 ? (brCovered / brTotal) * 100 : 100;
+            files.set(file, {
+                file,
+                lines: { total: linesTotal, covered: linesCovered, percentage: linePercentage },
+                functions: { total: fnTotal, covered: fnCovered, percentage: fnPercentage },
+                branches: { total: brTotal, covered: brCovered, percentage: brPercentage },
+                uncoveredLines,
+                uncoveredFunctions,
+            });
+            totalLines += linesTotal;
+            coveredLines += linesCovered;
+            totalFunctions += fnTotal;
+            coveredFunctions += fnCovered;
+            totalBranches += brTotal;
+            coveredBranches += brCovered;
+            if (linePercentage < 50) {
+                lowCoverageFiles.push(file);
+            }
+            if (linePercentage === 0 && linesTotal > 0) {
+                uncoveredFiles.push(file);
+            }
+        }
+    }
+    catch (e) {
+        // Return empty summary on error
+    }
+    return {
+        files,
+        overall: {
+            lines: totalLines > 0 ? (coveredLines / totalLines) * 100 : 0,
+            functions: totalFunctions > 0 ? (coveredFunctions / totalFunctions) * 100 : 0,
+            branches: totalBranches > 0 ? (coveredBranches / totalBranches) * 100 : 0,
+        },
+        lowCoverageFiles,
+        uncoveredFiles,
+    };
+}
+/**
+ * Find coverage report in project
+ */
+function findCoverageReport(projectRoot = process.cwd()) {
+    const possiblePaths = [
+        'coverage/coverage-final.json',
+        'coverage/coverage-summary.json',
+        '.nyc_output/coverage.json',
+        'coverage.json',
+        'coverage/lcov.info',
+    ];
+    for (const p of possiblePaths) {
+        const fullPath = path.join(projectRoot, p);
+        if (fs.existsSync(fullPath)) {
+            return fullPath;
+        }
+    }
+    return null;
+}
+/**
+ * Get coverage data for a specific file
+ */
+function getFileCoverage(file, summary) {
+    if (!summary) {
+        const reportPath = findCoverageReport();
+        if (!reportPath)
+            return null;
+        summary = parseIstanbulCoverage(reportPath);
+    }
+    // Try exact match first
+    if (summary.files.has(file)) {
+        return summary.files.get(file);
+    }
+    // Try matching by basename
+    const basename = path.basename(file);
+    for (const [key, data] of summary.files) {
+        if (key.endsWith(file) || key.endsWith(basename)) {
+            return data;
+        }
+    }
+    return null;
+}
+/**
+ * Suggest tests for files based on coverage
+ */
+function suggestTests(files, summary) {
+    if (!summary) {
+        const reportPath = findCoverageReport();
+        if (reportPath) {
+            summary = parseIstanbulCoverage(reportPath);
+        }
+    }
+    const suggestions = [];
+    for (const file of files) {
+        const coverage = summary ? getFileCoverage(file, summary) : null;
+        // Determine test file path
+        const ext = path.extname(file);
+        const base = path.basename(file, ext);
+        const dir = path.dirname(file);
+        const possibleTestFiles = [
+            path.join(dir, `${base}.test${ext}`),
+            path.join(dir, `${base}.spec${ext}`),
+            path.join(dir, '__tests__', `${base}.test${ext}`),
+            path.join('test', `${base}.test${ext}`),
+            path.join('tests', `${base}.test${ext}`),
+        ];
+        const existingTestFile = possibleTestFiles.find(t => fs.existsSync(t));
+        const testFile = existingTestFile || possibleTestFiles[0];
+        if (!coverage) {
+            suggestions.push({
+                file,
+                testFile,
+                reason: 'No coverage data - needs test file',
+                priority: 'high',
+                coverage: 0,
+                uncoveredFunctions: [],
+            });
+        }
+        else if (coverage.lines.percentage < 30) {
+            suggestions.push({
+                file,
+                testFile,
+                reason: `Very low coverage (${coverage.lines.percentage.toFixed(1)}%)`,
+                priority: 'high',
+                coverage: coverage.lines.percentage,
+                uncoveredFunctions: coverage.uncoveredFunctions,
+            });
+        }
+        else if (coverage.lines.percentage < 70) {
+            suggestions.push({
+                file,
+                testFile,
+                reason: `Low coverage (${coverage.lines.percentage.toFixed(1)}%)`,
+                priority: 'medium',
+                coverage: coverage.lines.percentage,
+                uncoveredFunctions: coverage.uncoveredFunctions,
+            });
+        }
+        else if (coverage.uncoveredFunctions.length > 0) {
+            suggestions.push({
+                file,
+                testFile,
+                reason: `${coverage.uncoveredFunctions.length} untested functions`,
+                priority: 'low',
+                coverage: coverage.lines.percentage,
+                uncoveredFunctions: coverage.uncoveredFunctions,
+            });
+        }
+    }
+    return suggestions.sort((a, b) => {
+        const priorityOrder = { high: 0, medium: 1, low: 2 };
+        return priorityOrder[a.priority] - priorityOrder[b.priority];
+    });
+}
+/**
+ * Determine if a file needs the tester agent based on coverage
+ */
+function shouldRouteToTester(file, summary) {
+    const coverage = getFileCoverage(file, summary);
+    if (!coverage) {
+        return {
+            route: true,
+            reason: 'No test coverage data available',
+            coverage: 0,
+        };
+    }
+    if (coverage.lines.percentage < 50) {
+        return {
+            route: true,
+            reason: `Low coverage: ${coverage.lines.percentage.toFixed(1)}%`,
+            coverage: coverage.lines.percentage,
+        };
+    }
+    if (coverage.uncoveredFunctions.length > 3) {
+        return {
+            route: true,
+            reason: `${coverage.uncoveredFunctions.length} untested functions`,
+            coverage: coverage.lines.percentage,
+        };
+    }
+    return {
+        route: false,
+        reason: `Adequate coverage: ${coverage.lines.percentage.toFixed(1)}%`,
+        coverage: coverage.lines.percentage,
+    };
+}
+/**
+ * Get coverage-aware routing weight for agent selection
+ */
+function getCoverageRoutingWeight(file, summary) {
+    const coverage = getFileCoverage(file, summary);
+    if (!coverage) {
+        // No coverage = prioritize testing
+        return { coder: 0.3, tester: 0.5, reviewer: 0.2 };
+    }
+    const pct = coverage.lines.percentage;
+    if (pct < 30) {
+        // Very low - strongly prioritize testing
+        return { coder: 0.2, tester: 0.6, reviewer: 0.2 };
+    }
+    else if (pct < 60) {
+        // Low - moderate testing priority
+        return { coder: 0.4, tester: 0.4, reviewer: 0.2 };
+    }
+    else if (pct < 80) {
+        // Okay - balanced
+        return { coder: 0.5, tester: 0.3, reviewer: 0.2 };
+    }
+    else {
+        // Good - focus on code quality
+        return { coder: 0.5, tester: 0.2, reviewer: 0.3 };
+    }
+}
+exports.default = {
+    parseIstanbulCoverage,
+    findCoverageReport,
+    getFileCoverage,
+    suggestTests,
+    shouldRouteToTester,
+    getCoverageRoutingWeight,
+};