@memberjunction/ai-agents 5.37.0 → 5.38.0

package/dist/artifact-tools/DataSnapshotToolLibrary.js

@@ -8,7 +8,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
  * @fileoverview Artifact tool library for DataSnapshot content.
  *
  * Parses a DataSnapshot JSON string and exposes tools for inspecting
- * table metadata, slicing rows, searching, and aggregating values.
+ * table metadata, slicing rows, searching, aggregating, grouping,
+ * computing derived columns, and multi-condition filtering.
  */
 import { RegisterClass } from '@memberjunction/global';
 import { NormalizeToTables } from '@memberjunction/core';
@@ -18,8 +19,184 @@ const VALID_SEARCH_OPERATORS = new Set([
 ]);
 const VALID_AGGREGATE_OPS = new Set([
     'sum', 'avg', 'mean', 'count', 'min', 'max', 'distinct_count',
-    'median', 'mode', 'stdev', 'variance',
+    'median', 'percentile', 'mode', 'stdev', 'variance',
 ]);
+const EXPR_FUNCTIONS = new Set([
+    'abs', 'round', 'floor', 'ceil', 'sqrt', 'min', 'max',
+]);
+class ExpressionParser {
+    constructor() {
+        this.tokens = [];
+        this.pos = 0;
+    }
+    /** Parse `expression` into an AST. Throws Error with a human-readable message on failure. */
+    parse(expression) {
+        this.tokens = this.tokenize(expression);
+        this.pos = 0;
+        if (this.tokens.length === 0) {
+            throw new Error('Expression is empty.');
+        }
+        const node = this.parseExpr();
+        if (this.pos < this.tokens.length) {
+            throw new Error(`Unexpected token "${this.peekRaw()}" in expression.`);
+        }
+        return node;
+    }
+    tokenize(src) {
+        const out = [];
+        let i = 0;
+        while (i < src.length) {
+            const ch = src[i];
+            if (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r') {
+                i++;
+                continue;
+            }
+            if ('+-*/(),'.includes(ch)) {
+                out.push({ kind: 'op', value: ch });
+                i++;
+                continue;
+            }
+            if (ch >= '0' && ch <= '9' || (ch === '.' && /[0-9]/.test(src[i + 1] ?? ''))) {
+                let j = i + 1;
+                while (j < src.length && /[0-9.]/.test(src[j]))
+                    j++;
+                const numStr = src.slice(i, j);
+                const value = Number(numStr);
+                if (!Number.isFinite(value))
+                    throw new Error(`Invalid number "${numStr}" in expression.`);
+                out.push({ kind: 'num', value });
+                i = j;
+                continue;
+            }
+            if (/[A-Za-z_]/.test(ch)) {
+                let j = i + 1;
+                while (j < src.length && /[A-Za-z0-9_]/.test(src[j]))
+                    j++;
+                out.push({ kind: 'ident', value: src.slice(i, j) });
+                i = j;
+                continue;
+            }
+            throw new Error(`Unexpected character "${ch}" in expression. Only field names, numbers, + - * / ( ) , and functions (${[...EXPR_FUNCTIONS].join(', ')}) are allowed.`);
+        }
+        return out;
+    }
+    peek() { return this.tokens[this.pos]; }
+    peekRaw() {
+        const t = this.peek();
+        return t ? String('value' in t ? t.value : '') : 'end of expression';
+    }
+    next() { return this.tokens[this.pos++]; }
+    isOp(v) {
+        const t = this.peek();
+        return !!t && t.kind === 'op' && t.value === v;
+    }
+    parseExpr() {
+        let left = this.parseTerm();
+        while (this.isOp('+') || this.isOp('-')) {
+            const op = this.next().value;
+            const right = this.parseTerm();
+            left = { type: 'binary', op, left, right };
+        }
+        return left;
+    }
+    parseTerm() {
+        let left = this.parseFactor();
+        while (this.isOp('*') || this.isOp('/')) {
+            const op = this.next().value;
+            const right = this.parseFactor();
+            left = { type: 'binary', op, left, right };
+        }
+        return left;
+    }
+    parseFactor() {
+        if (this.isOp('-')) {
+            this.next();
+            return { type: 'unary', operand: this.parseFactor() };
+        }
+        if (this.isOp('+')) {
+            this.next();
+            return this.parseFactor();
+        }
+        return this.parsePrimary();
+    }
+    parsePrimary() {
+        const t = this.next();
+        if (!t)
+            throw new Error('Unexpected end of expression.');
+        if (t.kind === 'num')
+            return { type: 'num', value: t.value };
+        if (t.kind === 'op' && t.value === '(') {
+            const inner = this.parseExpr();
+            if (!this.isOp(')'))
+                throw new Error('Missing closing ")" in expression.');
+            this.next();
+            return inner;
+        }
+        if (t.kind === 'ident') {
+            // function call?
+            if (this.isOp('(')) {
+                const name = t.value.toLowerCase();
+                if (!EXPR_FUNCTIONS.has(name)) {
+                    throw new Error(`Unknown function "${t.value}". Allowed: ${[...EXPR_FUNCTIONS].join(', ')}.`);
+                }
+                this.next(); // consume '('
+                const args = [];
+                if (!this.isOp(')')) {
+                    args.push(this.parseExpr());
+                    while (this.isOp(',')) {
+                        this.next();
+                        args.push(this.parseExpr());
+                    }
+                }
+                if (!this.isOp(')'))
+                    throw new Error(`Missing closing ")" for function "${t.value}".`);
+                this.next();
+                return { type: 'call', name, args };
+            }
+            return { type: 'field', name: t.value };
+        }
+        throw new Error(`Unexpected token "${'value' in t ? t.value : ''}" in expression.`);
+    }
+}
+/**
+ * Evaluate a parsed expression against a row. Returns NaN when the expression
+ * references a missing/non-numeric field or produces a non-finite value; the
+ * caller converts NaN to null for output/sorting.
+ */
+function evaluateExpr(node, row) {
+    switch (node.type) {
+        case 'num': return node.value;
+        case 'field': {
+            const v = row[node.name];
+            return typeof v === 'number' && Number.isFinite(v) ? v : NaN;
+        }
+        case 'unary': return -evaluateExpr(node.operand, row);
+        case 'binary': {
+            const l = evaluateExpr(node.left, row);
+            const r = evaluateExpr(node.right, row);
+            switch (node.op) {
+                case '+': return l + r;
+                case '-': return l - r;
+                case '*': return l * r;
+                case '/': return r === 0 ? NaN : l / r;
+            }
+            return NaN;
+        }
+        case 'call': {
+            const a = node.args.map(arg => evaluateExpr(arg, row));
+            switch (node.name) {
+                case 'abs': return Math.abs(a[0]);
+                case 'round': return Math.round(a[0]);
+                case 'floor': return Math.floor(a[0]);
+                case 'ceil': return Math.ceil(a[0]);
+                case 'sqrt': return Math.sqrt(a[0]);
+                case 'min': return Math.min(...a);
+                case 'max': return Math.max(...a);
+            }
+            return NaN;
+        }
+    }
+}
 // ---------------------------------------------------------------------------
 // DataSnapshotToolLibrary
 // ---------------------------------------------------------------------------
@@ -58,7 +235,7 @@ let DataSnapshotToolLibrary = class DataSnapshotToolLibrary extends BaseArtifact
             },
             {
                 name: 'search_rows',
-                description: 'Returns rows matching a field condition (max 200 rows). Operators: eq, neq, gt, lt, gte, lte, contains, startsWith.',
+                description: 'Returns rows matching a SINGLE field condition (max 200 rows). Operators: eq, neq, gt, lt, gte, lte, contains, startsWith. For multiple conditions (AND/OR), use `filter`.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -74,11 +251,12 @@ let DataSnapshotToolLibrary = class DataSnapshotToolLibrary extends BaseArtifact
             {
                 name: 'aggregate',
                 description: 'Computes an aggregate over a field. Operations: ' +
-                    'sum, avg (alias: mean), count, min, max, distinct_count, median, mode, stdev (sample), variance (sample). ' +
+                    'sum, avg (alias: mean), count, min, max, distinct_count, median, percentile (requires `p`), mode, stdev (sample), variance (sample). ' +
                     'Returns an object { value, ...context }. ' +
                     'For min/max the object also includes `contributingRows` — rows whose field equals the extremum. ' +
                     'For distinct_count, the object includes `distinctValues` — the actual distinct values found. ' +
                     'For mode, the object includes `frequency` (how many rows), `contributingRows`, and `allModes` when there is a tie. ' +
+                    'percentile uses linear interpolation (e.g. p=90 → 90th percentile; median is percentile with p=50). ' +
                     'stdev/variance skip null/non-numeric values and use the sample divisor (N-1). ' +
                     'Use these context fields directly — do not guess the identity from the scalar alone.',
                 inputSchema: {
@@ -87,10 +265,104 @@ let DataSnapshotToolLibrary = class DataSnapshotToolLibrary extends BaseArtifact
                         table: { type: 'string' },
                         field: { type: 'string' },
                         operation: { type: 'string' },
+                        p: { type: 'number', description: 'Percentile 0-100. Required when operation is "percentile".' },
                     },
                     required: ['table', 'field', 'operation'],
                 },
             },
+            {
+                name: 'group_aggregate',
+                description: 'GROUP BY one or more fields and compute one or more aggregations per group (SQL "GROUP BY ... [HAVING] ... [ORDER BY] ... [LIMIT]"). ' +
+                    'Use this for rollups like "total revenue by category" or "avg hours by level" — do NOT delegate these to a sub-agent. ' +
+                    'Each aggregation is { field, operation, alias, p? } where operation is any `aggregate` operation (count may omit field). ' +
+                    'Returns { groups: [{ <groupBy fields>, <alias>: value, ... }], groupCount }.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        table: { type: 'string' },
+                        groupBy: { type: 'array', items: { type: 'string' }, description: 'One or more fields to group by.' },
+                        aggregations: {
+                            type: 'array',
+                            description: 'Each: { field, operation, alias, p? }. operation = sum/avg/count/min/max/distinct_count/median/percentile/mode/stdev/variance.',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    field: { type: 'string' },
+                                    operation: { type: 'string' },
+                                    alias: { type: 'string' },
+                                    p: { type: 'number' },
+                                },
+                                required: ['operation', 'alias'],
+                            },
+                        },
+                        having: {
+                            type: 'object',
+                            description: 'Optional post-aggregation filter on an aggregation alias: { alias, operator, value }. Operators as in search_rows.',
+                            properties: {
+                                alias: { type: 'string' },
+                                operator: { type: 'string' },
+                                value: {},
+                            },
+                        },
+                        sort: {
+                            type: 'object',
+                            description: 'Optional { by, direction }. `by` is a groupBy field or an aggregation alias; direction is "asc" or "desc".',
+                            properties: {
+                                by: { type: 'string' },
+                                direction: { type: 'string' },
+                            },
+                        },
+                        limit: { type: 'number', description: 'Optional max number of groups to return.' },
+                    },
+                    required: ['table', 'groupBy', 'aggregations'],
+                },
+            },
+            {
+                name: 'compute',
+                description: 'Adds a derived column from a safe arithmetic expression over numeric fields, then optionally sorts by it and returns the top/bottom N rows. ' +
+                    'Use this for per-row metrics + ranking like "best price-to-hours ratio" (expression "Price / DurationHours", sort "desc", limit 10) — do NOT delegate these to a sub-agent. ' +
+                    'Expression supports field names, numbers, + - * /, parentheses, unary minus, and functions: ' + [...EXPR_FUNCTIONS].join(', ') + '. ' +
+                    'Rows where the expression is undefined (missing/non-numeric field, divide-by-zero) get null for the computed column and sort last. ' +
+                    'Returns { rows: [original fields + <as>], totalRows, truncated? }.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        table: { type: 'string' },
+                        expression: { type: 'string', description: 'e.g. "Price / DurationHours" or "(Revenue - Cost) / Revenue".' },
+                        as: { type: 'string', description: 'Name for the computed column.' },
+                        sort: { type: 'string', description: 'Optional "asc" or "desc" — sorts by the computed column.' },
+                        limit: { type: 'number', description: 'Optional max rows to return (top/bottom N after sort).' },
+                    },
+                    required: ['table', 'expression', 'as'],
+                },
+            },
+            {
+                name: 'filter',
+                description: 'Returns rows matching MULTIPLE field conditions combined with AND/OR (max 200 rows by default). ' +
+                    'Each condition is { field, operator, value }; operators: eq, neq, gt, lt, gte, lte, contains, startsWith. ' +
+                    'Use for "Price > 100 AND Level = \'Advanced\'". For a single condition, search_rows is simpler.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        table: { type: 'string' },
+                        conditions: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    field: { type: 'string' },
+                                    operator: { type: 'string' },
+                                    value: {},
+                                },
+                                required: ['field', 'operator', 'value'],
+                            },
+                        },
+                        combine: { type: 'string', description: '"and" (default) or "or".' },
+                        limit: { type: 'number', description: 'Max rows to return. Default: 200' },
+                    },
+                    required: ['table', 'conditions'],
+                },
+            },
         ];
     }
     // -----------------------------------------------------------------------
@@ -125,6 +397,12 @@ let DataSnapshotToolLibrary = class DataSnapshotToolLibrary extends BaseArtifact
                 return this.handleSearchRows(payload, input);
             case 'aggregate':
                 return this.handleAggregate(payload, input);
+            case 'group_aggregate':
+                return this.handleGroupAggregate(payload, input);
+            case 'compute':
+                return this.handleCompute(payload, input);
+            case 'filter':
+                return this.handleFilter(payload, input);
             default:
                 return this.errorResult(`Unknown tool: "${toolName}".`);
         }
@@ -188,9 +466,196 @@ let DataSnapshotToolLibrary = class DataSnapshotToolLibrary extends BaseArtifact
         if (!VALID_AGGREGATE_OPS.has(operation)) {
             return this.errorResult(`Unsupported aggregate operation: "${operation}". Valid operations: ${[...VALID_AGGREGATE_OPS].join(', ')}.`);
         }
-        const result = this.computeAggregate(table.rows, field, operation);
+        let p;
+        if (operation === 'percentile') {
+            p = input.p;
+            if (typeof p !== 'number' || !Number.isFinite(p) || p < 0 || p > 100) {
+                return this.errorResult(`The "percentile" operation requires a numeric "p" between 0 and 100 (got ${JSON.stringify(input.p)}).`);
+            }
+        }
+        const result = this.computeAggregate(table.rows, field, operation, p);
         return this.successResult(result);
     }
+    handleGroupAggregate(payload, input) {
+        const table = this.findTable(payload, input.table);
+        if (!table) {
+            return this.tableNotFoundError(input.table);
+        }
+        const groupBy = Array.isArray(input.groupBy)
+            ? input.groupBy.map(g => String(g))
+            : [];
+        if (groupBy.length === 0) {
+            return this.errorResult('`groupBy` must be a non-empty array of field names.');
+        }
+        const rawAggs = Array.isArray(input.aggregations) ? input.aggregations : [];
+        if (rawAggs.length === 0) {
+            return this.errorResult('`aggregations` must be a non-empty array of { field, operation, alias, p? }.');
+        }
+        const aggs = [];
+        for (const a of rawAggs) {
+            const operation = String(a.operation ?? '');
+            const alias = String(a.alias ?? '');
+            const fieldName = a.field !== undefined ? String(a.field) : '';
+            if (!VALID_AGGREGATE_OPS.has(operation)) {
+                return this.errorResult(`Unsupported aggregate operation "${operation}". Valid operations: ${[...VALID_AGGREGATE_OPS].join(', ')}.`);
+            }
+            if (!alias) {
+                return this.errorResult('Every aggregation requires an "alias".');
+            }
+            if (operation !== 'count' && !fieldName) {
+                return this.errorResult(`Aggregation "${alias}" (operation "${operation}") requires a "field".`);
+            }
+            let p;
+            if (operation === 'percentile') {
+                p = a.p;
+                if (typeof p !== 'number' || !Number.isFinite(p) || p < 0 || p > 100) {
+                    return this.errorResult(`Aggregation "${alias}" uses "percentile" and requires a numeric "p" between 0 and 100.`);
+                }
+            }
+            aggs.push({ field: fieldName, operation: operation, alias, p });
+        }
+        // Bucket rows by composite group key.
+        const buckets = new Map();
+        for (const row of table.rows) {
+            const keyValues = {};
+            for (const g of groupBy)
+                keyValues[g] = row[g];
+            const key = JSON.stringify(groupBy.map(g => row[g] ?? null));
+            let bucket = buckets.get(key);
+            if (!bucket) {
+                bucket = { keyValues, rows: [] };
+                buckets.set(key, bucket);
+            }
+            bucket.rows.push(row);
+        }
+        // Build group rows: group-by values + each aggregation's scalar value.
+        let groups = [];
+        for (const bucket of buckets.values()) {
+            const groupRow = { ...bucket.keyValues };
+            for (const agg of aggs) {
+                groupRow[agg.alias] = this.computeAggregate(bucket.rows, agg.field, agg.operation, agg.p).value;
+            }
+            groups.push(groupRow);
+        }
+        // Optional HAVING filter on an aggregation alias.
+        if (input.having && typeof input.having === 'object') {
+            const having = input.having;
+            const alias = String(having.alias ?? '');
+            const operator = String(having.operator ?? '');
+            if (!alias || !VALID_SEARCH_OPERATORS.has(operator)) {
+                return this.errorResult('`having` must be { alias, operator, value } with a valid operator.');
+            }
+            groups = groups.filter(g => this.evaluateCondition(g[alias], operator, having.value));
+        }
+        // Optional sort by a group-by field or an aggregation alias.
+        if (input.sort && typeof input.sort === 'object') {
+            const sort = input.sort;
+            const by = String(sort.by ?? '');
+            const direction = String(sort.direction ?? 'asc').toLowerCase() === 'desc' ? 'desc' : 'asc';
+            if (by)
+                groups = this.sortRows(groups, by, direction);
+        }
+        const groupCount = groups.length;
+        const limit = input.limit;
+        const truncated = typeof limit === 'number' && limit >= 0 && groupCount > limit;
+        if (truncated)
+            groups = groups.slice(0, limit);
+        return this.successResult({
+            groups,
+            groupCount,
+            ...(truncated ? { truncated: true } : {}),
+        });
+    }
+    handleCompute(payload, input) {
+        const table = this.findTable(payload, input.table);
+        if (!table) {
+            return this.tableNotFoundError(input.table);
+        }
+        const expression = input.expression;
+        const as = input.as;
+        if (typeof expression !== 'string' || expression.trim().length === 0) {
+            return this.errorResult('`expression` is required (e.g. "Price / DurationHours").');
+        }
+        if (typeof as !== 'string' || as.trim().length === 0) {
+            return this.errorResult('`as` (name for the computed column) is required.');
+        }
+        let ast;
+        try {
+            ast = new ExpressionParser().parse(expression);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return this.errorResult(`Could not parse expression "${expression}": ${msg}`);
+        }
+        // Compute the derived column per row (NaN/non-finite → null).
+        const computed = table.rows.map(row => {
+            const raw = evaluateExpr(ast, row);
+            const value = Number.isFinite(raw) ? raw : null;
+            return { ...row, [as]: value };
+        });
+        // Optional sort by the computed column; nulls always sort last.
+        let rows = computed;
+        const sortRaw = typeof input.sort === 'string' ? input.sort.toLowerCase() : undefined;
+        if (sortRaw === 'asc' || sortRaw === 'desc') {
+            rows = [...computed].sort((a, b) => {
+                const av = a[as];
+                const bv = b[as];
+                if (av === null && bv === null)
+                    return 0;
+                if (av === null)
+                    return 1;
+                if (bv === null)
+                    return -1;
+                return sortRaw === 'asc' ? av - bv : bv - av;
+            });
+        }
+        const totalRows = rows.length;
+        const limit = input.limit;
+        const truncated = typeof limit === 'number' && limit >= 0 && totalRows > limit;
+        if (truncated)
+            rows = rows.slice(0, limit);
+        return this.successResult({
+            rows,
+            totalRows,
+            ...(truncated ? { truncated: true } : {}),
+        });
+    }
+    handleFilter(payload, input) {
+        const table = this.findTable(payload, input.table);
+        if (!table) {
+            return this.tableNotFoundError(input.table);
+        }
+        const rawConditions = Array.isArray(input.conditions) ? input.conditions : [];
+        if (rawConditions.length === 0) {
+            return this.errorResult('`conditions` must be a non-empty array of { field, operator, value }.');
+        }
+        const conditions = [];
+        for (const c of rawConditions) {
+            const field = String(c.field ?? '');
+            const operator = String(c.operator ?? '');
+            if (!field || !VALID_SEARCH_OPERATORS.has(operator)) {
+                return this.errorResult(`Each condition needs a "field" and a valid "operator" (${[...VALID_SEARCH_OPERATORS].join(', ')}). Got field="${field}", operator="${operator}".`);
+            }
+            conditions.push({ field, operator: operator, value: c.value });
+        }
+        const combine = String(input.combine ?? 'and').toLowerCase() === 'or' ? 'or' : 'and';
+        const limit = Math.min(input.limit ?? 200, 500);
+        const matches = (row) => {
+            if (combine === 'or') {
+                return conditions.some(c => this.evaluateCondition(row[c.field], c.operator, c.value));
+            }
+            return conditions.every(c => this.evaluateCondition(row[c.field], c.operator, c.value));
+        };
+        const allMatched = table.rows.filter(matches);
+        const truncated = allMatched.length > limit;
+        const rows = truncated ? allMatched.slice(0, limit) : allMatched;
+        return this.successResult({
+            rows,
+            totalMatches: allMatched.length,
+            combine,
+            ...(truncated ? { truncated: true, note: `Showing ${limit} of ${allMatched.length} matches. Use the 'limit' parameter or narrow your conditions.` } : {}),
+        });
+    }
     // -----------------------------------------------------------------------
     // Search condition evaluator
     // -----------------------------------------------------------------------
@@ -215,9 +680,32 @@ let DataSnapshotToolLibrary = class DataSnapshotToolLibrary extends BaseArtifact
         }
     }
     // -----------------------------------------------------------------------
+    // Sort helper (shared by group_aggregate)
+    // -----------------------------------------------------------------------
+    sortRows(rows, by, direction) {
+        return [...rows].sort((a, b) => {
+            const av = a[by];
+            const bv = b[by];
+            // Nulls/undefined last regardless of direction.
+            const aNull = av === null || av === undefined;
+            const bNull = bv === null || bv === undefined;
+            if (aNull && bNull)
+                return 0;
+            if (aNull)
+                return 1;
+            if (bNull)
+                return -1;
+            if (typeof av === 'number' && typeof bv === 'number') {
+                return direction === 'asc' ? av - bv : bv - av;
+            }
+            const cmp = String(av).localeCompare(String(bv));
+            return direction === 'asc' ? cmp : -cmp;
+        });
+    }
+    // -----------------------------------------------------------------------
     // Aggregate computation
     // -----------------------------------------------------------------------
-    computeAggregate(rows, field, operation) {
+    computeAggregate(rows, field, operation, p) {
         const MAX_CONTRIBUTING_ROWS = 10;
         const MAX_DISTINCT_VALUES = 50;
         // Helper — extract finite numeric values for numeric-only operations.
@@ -260,16 +748,23 @@ let DataSnapshotToolLibrary = class DataSnapshotToolLibrary extends BaseArtifact
                     result.truncated = true;
                 return result;
             }
-            case 'median': {
+            case 'median':
+            case 'percentile': {
+                // median is percentile with p=50. Both use linear interpolation
+                // between the two closest ranks (matches the prior median impl:
+                // odd N → middle value, even N → mean of the two middle values).
                 const nums = numericValues();
                 if (nums.length === 0)
                     return { value: 0 };
                 nums.sort((a, b) => a - b);
-                const mid = Math.floor(nums.length / 2);
-                const median = nums.length % 2 === 0
-                    ? (nums[mid - 1] + nums[mid]) / 2
-                    : nums[mid];
-                return { value: median };
+                if (nums.length === 1)
+                    return { value: nums[0] };
+                const pp = operation === 'median' ? 50 : (p ?? 50);
+                const rank = (pp / 100) * (nums.length - 1);
+                const lo = Math.floor(rank);
+                const hi = Math.ceil(rank);
+                const value = nums[lo] + (nums[hi] - nums[lo]) * (rank - lo);
+                return { value };
             }
             case 'mode': {
                 if (rows.length === 0)