@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.0

package/vendor/aql/plan/execute.js

@@ -0,0 +1,829 @@
+import { evaluateNode } from '../evaluator/evaluateNode.js';
+import { ExpressionEvaluationError } from '../evaluator/ExpressionEvaluationError.js';
+import { createHostExpressionContext, deriveHostExpressionContext, } from '../host/createHostExpressionContext.js';
+import { hostGetRawColumnValue, hostGetRowRefs } from '../host/access.js';
+import { printExpression } from '../normalize/print.js';
+import { DeepMap } from './deepMap.js';
+import { isUndefinedValue, toFiniteNumber } from '../functions/utils.js';
+import { SYSTEM_AGGREGATION_CATALOGUE } from './catalogue.js';
+import { collectColumns } from './compile.js';
+import { evaluateObservableSlot, MISSING_HISTORY_MESSAGE } from './observable.js';
+import { rowEventSeriesKey } from '../store/history/types.js';
+import { SKIP_ROW, } from './operators.js';
+import { DEFAULT_ROW_SET_KIND, } from './types.js';
+const coerceValue = (rawValue) => rawValue instanceof Date ? rawValue.getTime() : rawValue;
+/**
+ * Lazily built host context shared by expression inputs, filters and the
+ * outer evaluator. Host-less runs never build one (the field fast path and a
+ * pure single-aggregation root need no context).
+ */
+const createLazyBaseContext = (config) => {
+    let baseContext;
+    return () => {
+        if (!baseContext) {
+            if (!config.host) {
+                throw new ExpressionEvaluationError('', 'expression inputs / filters require a bound host');
+            }
+            baseContext = createHostExpressionContext({
+                host: config.host,
+                functions: config.functions,
+                whereClauseFunctions: config.whereClauseFunctions,
+                history: config.history,
+                clock: config.clock,
+                ext: config.ext,
+            });
+        }
+        return baseContext;
+    };
+};
+/**
+ * Outer evaluation for one expression over its (already executed) slot
+ * results: the scalar evaluator runs the normalized root with each plan's
+ * `sourceNode` resolving to that plan's global value (row-independent
+ * reading) or per-row value (`getValueForRow`). A pure single-aggregation
+ * root short-circuits to the slot result — no scalar evaluation, no host.
+ */
+const assembleValueExecutionResult = (compiled, expressionResults, getBaseContext, config, fallbackRowCount = 0) => {
+    const rootSlot = isRootAggregation(compiled);
+    const observableSlots = compiled.observable ?? [];
+    // Earliest expiry seen by any observable read made through this result —
+    // accumulates across `getValueForRow` calls (the store reads it after the
+    // per-row reads of a flush).
+    let nextChangeAt;
+    const noteNext = (t) => {
+        if (t !== undefined && (nextChangeAt === undefined || t < nextChangeAt)) {
+            nextChangeAt = t;
+        }
+    };
+    // Grid-scope slots are the same for every row: read once per run.
+    const gridReads = new Map();
+    const readObservable = (slotIndex, rowRef) => {
+        const slot = observableSlots[slotIndex];
+        const history = config.history;
+        if (!history) {
+            throw new ExpressionEvaluationError(slot.source, MISSING_HISTORY_MESSAGE);
+        }
+        let read;
+        if (slot.key.scope === 'grid') {
+            const cached = gridReads.get(slotIndex);
+            if (cached) {
+                return cached.value;
+            }
+            read = evaluateObservableSlot(slot, history, undefined);
+            gridReads.set(slotIndex, read);
+        }
+        else {
+            const rowId = rowRef === undefined ? undefined : history.rowIdOf(rowRef);
+            read = evaluateObservableSlot(slot, history, rowId);
+        }
+        noteNext(read.nextChangeAt);
+        return read.value;
+    };
+    let value;
+    let getValueForRow;
+    if (rootSlot !== undefined) {
+        const rootResult = expressionResults[rootSlot];
+        value = rootResult.value;
+        getValueForRow = (rowRef) => rootResult.getValueForRow(rowRef);
+    }
+    else {
+        const slotByNode = new Map();
+        compiled.aggregations.forEach((plan, index) => slotByNode.set(plan.sourceNode, index));
+        const observableByNode = new Map();
+        observableSlots.forEach((slot, index) => observableByNode.set(slot.node, index));
+        let outerRowMode = false;
+        const outerContext = deriveHostExpressionContext(getBaseContext(), { filterFn: undefined });
+        outerContext.resolveContractNode = (node) => {
+            const slot = slotByNode.get(node);
+            if (slot !== undefined) {
+                return {
+                    value: outerRowMode
+                        ? expressionResults[slot].getValueForRow(outerContext.rowRef)
+                        : expressionResults[slot].value,
+                };
+            }
+            const observableIndex = observableByNode.get(node);
+            if (observableIndex !== undefined) {
+                return {
+                    value: readObservable(observableIndex, outerRowMode ? outerContext.rowRef : undefined),
+                };
+            }
+            return undefined;
+        };
+        const evaluateOuter = (rowRef, rowMode) => {
+            outerRowMode = rowMode;
+            outerContext.rowRef = rowRef;
+            try {
+                return evaluateNode(compiled.outerNode, outerContext);
+            }
+            finally {
+                outerRowMode = false;
+                outerContext.rowRef = undefined;
+            }
+        };
+        value = evaluateOuter(undefined, false);
+        getValueForRow = (rowRef) => evaluateOuter(rowRef, true);
+    }
+    // Seed the expiry from the series themselves: a row-scoped `WITHIN` slot
+    // has no row in the global reading, and the store must be able to arm its
+    // timer without depending on which rows subscribers happen to read.
+    if (config.history) {
+        for (const slot of observableSlots) {
+            if (slot.window.kind !== 'within') {
+                continue;
+            }
+            const key = slot.rowEventKind
+                ? rowEventSeriesKey(slot.rowEventKind, slot.key.filterKey)
+                : slot.key;
+            noteNext(config.history.nextExpiryAt(key, slot.window.ms));
+            // `NO_CHANGES` turns true at `epoch + d` with no history at all.
+            if (slot.source === 'NO_CHANGES') {
+                noteNext(config.history.nextEpochElapseAt(slot.window.ms, slot.key.scope));
+            }
+        }
+    }
+    return {
+        value,
+        getValueForRow,
+        aggregations: expressionResults,
+        rowCount: expressionResults[0]?.rowCount ?? fallbackRowCount,
+        get nextChangeAt() {
+            return nextChangeAt;
+        },
+    };
+};
+/**
+ * Batch execution: every aggregation plan from every expression joins ONE
+ * signature-grouped scan pool, so expressions sharing a row set share a
+ * single host row pass (the store's cross-node scan grouping). Results are
+ * returned in input order.
+ */
+export const executeValueExpressionBatch = (compiledExpressions, config) => {
+    const registry = config.registry ?? SYSTEM_AGGREGATION_CATALOGUE;
+    const host = config.host;
+    const sortDirection = config.sort === 'desc' ? -1 : 1;
+    // --- value readers ---------------------------------------------------------
+    const readRaw = (rowRef, columnId) => config.getValue
+        ? config.getValue(rowRef, columnId)
+        : host
+            ? hostGetRawColumnValue(host, rowRef, columnId)
+            : undefined;
+    const readValue = (rowRef, columnId) => coerceValue(readRaw(rowRef, columnId));
+    // Contexts are needed only for expression inputs, filters and the outer
+    // evaluator; the field fast path never touches them.
+    const getBaseContext = createLazyBaseContext(config);
+    const prepareRowEvaluator = (node, functions) => {
+        const context = deriveHostExpressionContext(getBaseContext(), {
+            ...(functions ? { functions } : {}),
+            filterFn: undefined,
+        });
+        return (rowRef) => {
+            context.rowRef = rowRef;
+            return evaluateNode(node, context);
+        };
+    };
+    const resolveInput = (input) => {
+        if (input.kind === 'field') {
+            const { field } = input;
+            return (rowRef) => readValue(rowRef, field);
+        }
+        const evaluator = prepareRowEvaluator(input.node);
+        return (rowRef) => coerceValue(evaluator(rowRef));
+    };
+    const resolveRawInput = (input) => {
+        if (input.kind === 'field') {
+            const { field } = input;
+            return (rowRef) => readRaw(rowRef, field);
+        }
+        return prepareRowEvaluator(input.node);
+    };
+    // --- filter / row-set resolution ---------------------------------------------
+    const nodeIds = new Map();
+    const idOf = (node) => {
+        let id = nodeIds.get(node);
+        if (id === undefined) {
+            id = nodeIds.size;
+            nodeIds.set(node, id);
+        }
+        return id;
+    };
+    // Textually identical predicates / sort expressions from different call
+    // sites are different AST nodes — key caches by canonical text so those
+    // plans share one row pass (and one sorted copy).
+    const exprKeys = new Map();
+    const exprKey = (expression) => {
+        let key = exprKeys.get(expression);
+        if (key === undefined) {
+            try {
+                key = `p:${printExpression(expression)}`;
+            }
+            catch {
+                key = `n:${idOf(expression)}`;
+            }
+            exprKeys.set(expression, key);
+        }
+        return key;
+    };
+    const predicateFns = new Map();
+    const predicateFn = (predicate) => {
+        let fn = predicateFns.get(predicate);
+        if (!fn) {
+            const evaluator = prepareRowEvaluator(predicate, config.whereClauseFunctions ?? config.functions);
+            fn = (rowRef) => Boolean(evaluator(rowRef));
+            predicateFns.set(predicate, fn);
+        }
+        return fn;
+    };
+    const explicitRows = (() => {
+        if (config.rowRefs) {
+            return config.rowRefs;
+        }
+        return config.getRowRefs?.();
+    })();
+    const scanCache = new Map();
+    const resolveScanRows = (plan) => {
+        const predicates = plan.scanSignature.filterPredicates ?? [];
+        const key = `${plan.scanSignature.rowSetKind}|${predicates.map(exprKey).sort().join(',')}`;
+        let state = scanCache.get(key);
+        if (state) {
+            return state;
+        }
+        const filters = predicates.map(predicateFn);
+        const combined = filters.length === 0
+            ? undefined
+            : (rowRef) => filters.every((filter) => filter(rowRef));
+        const kindRows = plan.scanSignature.rowSetKind !== 'default'
+            ? config.resolveRowSet?.(plan.scanSignature.rowSetKind)
+            : undefined;
+        const baseRows = kindRows ?? explicitRows;
+        const rows = baseRows
+            ? combined
+                ? baseRows.filter(combined)
+                : baseRows
+            : hostGetRowRefs(host, combined ? { filterFn: combined } : undefined) ?? [];
+        state = { rows };
+        scanCache.set(key, state);
+        return state;
+    };
+    const sortKeyOf = (sort) => `${sort.direction}:${sort.input.kind === 'field' ? `f:${sort.input.field}` : `e:${exprKey(sort.input.node)}`}`;
+    const sortedCache = new Map();
+    const resolveSortedRows = (plan, scan) => {
+        const sort = plan.modifiers.cumulative?.over ?? plan.scanSignature.sort;
+        if (!sort) {
+            return scan.rows;
+        }
+        const key = `${idOf(scan)}|${sortKeyOf(sort)}`;
+        let sorted = sortedCache.get(key);
+        if (sorted) {
+            return sorted;
+        }
+        // Decorate–sort–undecorate: the key is read once per row and the scan
+        // array is never mutated (it is shared across plans in the group).
+        const keyOf = resolveInput(sort.input);
+        const direction = sort.direction === 'desc' ? -sortDirection : sortDirection;
+        const decorated = scan.rows.map((rowRef) => {
+            const key = keyOf(rowRef);
+            return { rowRef, key: key, blank: isUndefinedValue(key) };
+        });
+        // Blanks sort last in either direction.
+        decorated.sort((first, second) => {
+            if (first.blank || second.blank) {
+                return Number(first.blank) - Number(second.blank);
+            }
+            if (first.key < second.key) {
+                return -1 * direction;
+            }
+            if (first.key > second.key) {
+                return 1 * direction;
+            }
+            return 0;
+        });
+        sorted = decorated.map((entry) => entry.rowRef);
+        sortedCache.set(key, sorted);
+        return sorted;
+    };
+    const requireRowId = (functionName) => {
+        if (!host?.rows?.getRowId) {
+            throw new ExpressionEvaluationError(functionName, 'is not supported: host does not provide row identities (rows.getRowId)');
+        }
+        return (rowRef) => host.rows.getRowId(rowRef);
+    };
+    const optionalRowId = () => host?.rows?.getRowId ? (rowRef) => host.rows.getRowId(rowRef) : undefined;
+    // --- plan runtimes -------------------------------------------------------------
+    const allPlans = compiledExpressions.flatMap((compiled) => compiled.aggregations);
+    const runtimes = allPlans.map((plan, planIndex) => {
+        const operator = registry.get(plan.operator.name);
+        if (!operator) {
+            throw new ExpressionEvaluationError(plan.operator.name, 'is not a registered aggregation operator');
+        }
+        if (!plan.input) {
+            throw new ExpressionEvaluationError(plan.operator.name, 'has no input');
+        }
+        const spec = {
+            params: plan.operator.params,
+            inputType: plan.inputType,
+            hasWeight: !!plan.modifiers.weight,
+            inputField: plan.input?.kind === 'field' ? plan.input.field : undefined,
+            groupBy: plan.groupBy,
+        };
+        const runtime = {
+            plan,
+            operator,
+            spec,
+            inputOf: resolveInput(plan.input),
+            planIndex,
+        };
+        if (plan.modifiers.weight) {
+            runtime.weightOf = resolveRawInput(plan.modifiers.weight);
+        }
+        return runtime;
+    });
+    const runReducerPass = (rows, groupBy, passRuntimes) => {
+        const reducerOps = passRuntimes.map((runtime) => runtime.operator);
+        const initStates = () => passRuntimes.map((runtime, index) => reducerOps[index].init(runtime.spec));
+        const globalStates = initStates();
+        const grouped = !!groupBy?.length;
+        const groups = grouped ? new DeepMap() : undefined;
+        const rowId = optionalRowId();
+        const rowIdToGroupKeys = grouped && rowId ? new Map() : undefined;
+        for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+            const rowRef = rows[rowIndex];
+            // Legacy `aggregate()` parity: reducers accumulate at EVERY group-key
+            // prefix depth (`[make]`, `[make, currency]`, …), so `groupValues`
+            // exposes subtotal entries top-down. Per-row lookup stays full-depth.
+            let prefixStates;
+            if (grouped) {
+                const keys = groupBy.map((field) => readValue(rowRef, field));
+                prefixStates = [];
+                for (let depth = 1; depth <= keys.length; depth++) {
+                    const prefix = keys.slice(0, depth);
+                    if (!groups.has(prefix)) {
+                        groups.set(prefix, initStates());
+                    }
+                    prefixStates.push(groups.get(prefix));
+                }
+                if (rowIdToGroupKeys) {
+                    const id = rowId(rowRef);
+                    if (id !== undefined) {
+                        rowIdToGroupKeys.set(id, keys);
+                    }
+                }
+            }
+            for (let index = 0; index < passRuntimes.length; index++) {
+                const runtime = passRuntimes[index];
+                const operator = reducerOps[index];
+                const rowCtx = { rowRef, rowIndex };
+                if (runtime.weightOf) {
+                    rowCtx.weightValue = runtime.weightOf(rowRef);
+                }
+                if (operator.rowGate &&
+                    !operator.rowGate(rowRef, host?.getRowData(rowRef), runtime.spec, rowCtx)) {
+                    continue;
+                }
+                const value = runtime.inputOf(rowRef);
+                globalStates[index] = operator.step(runtime.spec, globalStates[index], value, rowCtx);
+                if (prefixStates) {
+                    for (const states of prefixStates) {
+                        states[index] = operator.step(runtime.spec, states[index], value, rowCtx);
+                    }
+                }
+            }
+        }
+        const finalize = (states) => states.map((state, index) => reducerOps[index].done ? reducerOps[index].done(passRuntimes[index].spec, state) : state);
+        const globalValues = finalize(globalStates);
+        if (groups) {
+            groups.visitDepthFirst((states, _keys, _indexInGroup, next) => {
+                // finalize in place: replace each state with its done() value
+                const finalized = finalize(states);
+                states.length = 0;
+                states.push(...finalized);
+                next?.();
+            });
+        }
+        return { globalValues, globalStates, groups, rowIdToGroupKeys, rows };
+    };
+    const partitionRows = (rows, groupBy) => {
+        if (!groupBy?.length) {
+            return { partitions: [{ rows }] };
+        }
+        const groups = new DeepMap();
+        for (const rowRef of rows) {
+            const keys = groupBy.map((field) => readValue(rowRef, field));
+            if (!groups.has(keys)) {
+                groups.set(keys, []);
+            }
+            groups.get(keys).push(rowRef);
+        }
+        return {
+            partitions: groups.topDownEntries().map(([keys, groupRows]) => ({ keys, rows: groupRows })),
+            groups,
+        };
+    };
+    const runWindowPlan = (runtime, sortedRows) => {
+        const operator = runtime.operator;
+        const rowId = requireRowId(runtime.plan.operator.name);
+        const { partitions } = partitionRows(sortedRows, runtime.plan.groupBy);
+        const rowIdToValue = new Map();
+        const groupValues = [];
+        let globalValue;
+        for (const partition of partitions) {
+            let rows = partition.rows;
+            let values = rows.map((rowRef) => runtime.inputOf(rowRef));
+            if (operator.partitionRowFilter) {
+                const keptRows = [];
+                const keptValues = [];
+                for (let index = 0; index < rows.length; index++) {
+                    if (operator.partitionRowFilter(values[index])) {
+                        keptRows.push(rows[index]);
+                        keptValues.push(values[index]);
+                    }
+                }
+                rows = keptRows;
+                values = keptValues;
+            }
+            const result = operator.run(runtime.spec, {
+                rowRefs: rows,
+                getValue: (index) => values[index],
+                getRowId: (index) => rowId(rows[index]),
+            });
+            result.rowValues.forEach((value, id) => rowIdToValue.set(id, value));
+            if (partition.keys) {
+                groupValues.push({ groupKeys: partition.keys, value: result.partitionValue });
+            }
+            else {
+                globalValue = result.partitionValue;
+            }
+        }
+        const grouped = !!runtime.plan.groupBy?.length;
+        return buildAggResult(runtime, {
+            value: globalValue,
+            groupValues: grouped ? groupValues : undefined,
+            rowIdToValue,
+            rowCount: sortedRows.length,
+            perRowOnly: true,
+        });
+    };
+    const runCumulativePlan = (runtime, sortedRows) => {
+        const operator = runtime.operator;
+        const variantFactory = operator.capabilities.cumulative;
+        if (!variantFactory) {
+            throw new ExpressionEvaluationError(runtime.plan.operator.name, 'does not support CUMULATIVE');
+        }
+        const rowId = requireRowId('CUMUL');
+        const { partitions } = partitionRows(sortedRows, runtime.plan.groupBy);
+        const rowIdToValue = new Map();
+        const groupValues = [];
+        let globalValue;
+        for (const partition of partitions) {
+            const variant = variantFactory(runtime.spec);
+            const state = variant.init();
+            const recorded = [];
+            for (let rowIndex = 0; rowIndex < partition.rows.length; rowIndex++) {
+                const rowRef = partition.rows[rowIndex];
+                const rowCtx = { rowRef, rowIndex };
+                if (runtime.weightOf) {
+                    rowCtx.weightValue = runtime.weightOf(rowRef);
+                }
+                // Operator-level row gate (custom `filterRow`) applies to the running
+                // walk as well: gated rows neither advance the state nor get a value.
+                if (operator.rowGate &&
+                    !operator.rowGate(rowRef, host?.getRowData(rowRef), runtime.spec, rowCtx)) {
+                    continue;
+                }
+                variant.step(state, runtime.inputOf(rowRef), rowCtx);
+                const current = variant.current(state);
+                if (current !== SKIP_ROW) {
+                    recorded.push({ id: rowId(rowRef), value: current });
+                }
+            }
+            for (const entry of recorded) {
+                rowIdToValue.set(entry.id, variant.finalizeRow ? variant.finalizeRow(entry.value, state) : entry.value);
+            }
+            const finalValue = variant.current(state);
+            const partitionValue = finalValue === SKIP_ROW ? undefined : finalValue;
+            if (partition.keys) {
+                groupValues.push({ groupKeys: partition.keys, value: partitionValue });
+            }
+            else {
+                globalValue = partitionValue;
+            }
+        }
+        const grouped = !!runtime.plan.groupBy?.length;
+        return buildAggResult(runtime, {
+            value: globalValue,
+            groupValues: grouped ? groupValues : undefined,
+            rowIdToValue,
+            rowCount: sortedRows.length,
+            perRowOnly: true,
+        });
+    };
+    // --- result assembly --------------------------------------------------------------
+    const applyProjection = (projection, rowRef, baseValue) => {
+        if (projection.kind === 'percentage') {
+            const cellValue = toFiniteNumber(readRaw(rowRef, projection.column));
+            if (cellValue === undefined || baseValue == null) {
+                return null;
+            }
+            return (cellValue / baseValue) * 100;
+        }
+        const cellValue = toFiniteNumber(readRaw(rowRef, projection.column));
+        const relativeValue = toFiniteNumber(baseValue);
+        if (cellValue === undefined || relativeValue === undefined) {
+            return null;
+        }
+        return projection.mode === 'absolute'
+            ? cellValue - relativeValue
+            : ((cellValue - relativeValue) / relativeValue) * 100;
+    };
+    const buildAggResult = (runtime, parts) => {
+        const projection = runtime.plan.projection;
+        const rowId = optionalRowId();
+        const baseValueForRow = (rowRef) => {
+            if (parts.perRowOnly) {
+                const id = rowId?.(rowRef);
+                return id === undefined ? undefined : parts.rowIdToValue?.get(id);
+            }
+            if (parts.groupValues) {
+                const id = rowId?.(rowRef);
+                if (id !== undefined && parts.rowIdToValue?.has(id)) {
+                    return parts.rowIdToValue.get(id);
+                }
+                return parts.groupLookup?.(rowRef);
+            }
+            return parts.value;
+        };
+        const projectCustom = (rowRef, baseValue) => {
+            const operator = runtime.operator;
+            if (operator.kind !== 'reducer' || !operator.projectRow) {
+                return baseValue;
+            }
+            const rowCtx = { rowRef, rowIndex: 0 };
+            if (runtime.weightOf) {
+                rowCtx.weightValue = runtime.weightOf(rowRef);
+            }
+            return operator.projectRow(runtime.spec, baseValue, rowCtx);
+        };
+        const getValueForRow = (rowRef) => {
+            const baseValue = baseValueForRow(rowRef);
+            if (parts.perRowOnly) {
+                // Legacy parity: per-row maps resolve through the map only; a diff
+                // projection over a missing per-row value yields null.
+                if (projection) {
+                    return applyProjection(projection, rowRef, baseValue);
+                }
+                // A cumulative reducer's per-row projection (custom `prepareRowValue`)
+                // applies to the running value recorded for the row; rows the walk
+                // never recorded stay undefined.
+                return baseValue === undefined ? undefined : projectCustom(rowRef, baseValue);
+            }
+            if (baseValue == undefined) {
+                return undefined;
+            }
+            if (projection) {
+                return applyProjection(projection, rowRef, baseValue);
+            }
+            return projectCustom(rowRef, baseValue);
+        };
+        return {
+            value: parts.value,
+            groupValues: parts.groupValues,
+            values: parts.groupValues ? parts.groupValues.map((entry) => entry.value) : [parts.value],
+            rowIdToValue: parts.rowIdToValue,
+            getValueForRow,
+            rowCount: parts.rowCount,
+        };
+    };
+    // --- execution --------------------------------------------------------------------
+    const aggResults = new Array(runtimes.length);
+    // Group shareable reducer passes: same scan rows, same sort, same groupBy.
+    const reducerGroups = new Map();
+    for (const runtime of runtimes) {
+        const scan = resolveScanRows(runtime.plan);
+        const sortedRows = resolveSortedRows(runtime.plan, scan);
+        if (runtime.operator.kind === 'window') {
+            aggResults[runtime.planIndex] = runWindowPlan(runtime, sortedRows);
+            continue;
+        }
+        if (runtime.plan.modifiers.cumulative) {
+            aggResults[runtime.planIndex] = runCumulativePlan(runtime, sortedRows);
+            continue;
+        }
+        const groupKey = `${idOf(sortedRows)}|${(runtime.plan.groupBy ?? []).join('\u0000')}`;
+        let group = reducerGroups.get(groupKey);
+        if (!group) {
+            group = { runtimes: [], rows: sortedRows };
+            reducerGroups.set(groupKey, group);
+        }
+        group.runtimes.push(runtime);
+    }
+    for (const group of reducerGroups.values()) {
+        const groupBy = group.runtimes[0].plan.groupBy;
+        const pass = runReducerPass(group.rows, groupBy, group.runtimes);
+        group.runtimes.forEach((runtime, index) => {
+            const grouped = !!groupBy?.length;
+            const groupValues = grouped
+                ? pass
+                    .groups.topDownEntries()
+                    .map(([groupKeys, values]) => ({ groupKeys, value: values[index] }))
+                : undefined;
+            const rowIdToValue = grouped && pass.rowIdToGroupKeys
+                ? (() => {
+                    const map = new Map();
+                    pass.rowIdToGroupKeys.forEach((keys, id) => {
+                        map.set(id, pass.groups.get(keys)?.[index]);
+                    });
+                    return map;
+                })()
+                : undefined;
+            const groupLookup = grouped
+                ? (rowRef) => {
+                    const keys = groupBy.map((field) => readValue(rowRef, field));
+                    return pass.groups.get(keys)?.[index];
+                }
+                : undefined;
+            const aggResult = buildAggResult(runtime, {
+                value: pass.globalValues[index],
+                groupValues,
+                rowIdToValue,
+                groupLookup,
+                rowCount: pass.rows.length,
+            });
+            if (isDeltaCapablePlan(runtime.plan, runtime.operator)) {
+                aggResult.accumulator = pass.globalStates[index];
+            }
+            aggResults[runtime.planIndex] = aggResult;
+        });
+    }
+    // --- outer evaluation (per expression, over the shared slot results) -----------
+    // A observable-only expression (the common Alert case `CHANGE_COUNT{…} >= 3`)
+    // never joined the scan pool; its row count is the explicit row set's.
+    const observableOnlyRowCount = (compiled) => compiled.aggregations.length === 0 && compiled.observable?.length ? explicitRows?.length ?? 0 : 0;
+    let slotBase = 0;
+    return compiledExpressions.map((compiled) => {
+        const firstSlot = slotBase;
+        slotBase += compiled.aggregations.length;
+        return assembleValueExecutionResult(compiled, aggResults.slice(firstSlot, slotBase), getBaseContext, config, observableOnlyRowCount(compiled));
+    });
+};
+export const executeValueExpression = (compiled, config) => executeValueExpressionBatch([compiled], config)[0];
+// --- incremental update -------------------------------------------------------------
+/**
+ * Whether a plan's result can be updated from a single cell change without a
+ * rescan: an ungrouped, unfiltered, unweighted, non-cumulative reducer over
+ * a bare column, whose operator declares `capabilities.delta`, with no
+ * per-row projection / row gate (custom `filterRow` / `prepareRowValue`).
+ * Grouped plans are excluded on purpose: a change would have to be applied
+ * at every prefix depth and re-fanned into the per-row map.
+ */
+const isDeltaCapablePlan = (plan, operator) => operator.kind === 'reducer' &&
+    !!operator.capabilities.delta &&
+    !operator.rowGate &&
+    !operator.projectRow &&
+    plan.input?.kind === 'field' &&
+    !plan.groupBy?.length &&
+    !plan.modifiers.cumulative &&
+    !plan.modifiers.weight &&
+    !plan.projection &&
+    !plan.scanSignature.filterPredicates?.length;
+/**
+ * Every column a plan reads during its scan — main input, WEIGHT, sort key,
+ * group keys, WHERE predicates and projection column. Memoized per plan
+ * object (plans are immutable IR).
+ */
+const planColumnsCache = new WeakMap();
+const planColumns = (plan) => {
+    let columns = planColumnsCache.get(plan);
+    if (columns) {
+        return columns;
+    }
+    const into = new Set();
+    const addInput = (input) => {
+        if (!input) {
+            return;
+        }
+        if (input.kind === 'field') {
+            into.add(input.field);
+        }
+        else {
+            collectColumns(input.node, into);
+        }
+    };
+    addInput(plan.input);
+    addInput(plan.modifiers.weight);
+    addInput(plan.modifiers.cumulative?.over.input);
+    addInput(plan.scanSignature.sort?.input);
+    plan.groupBy?.forEach((field) => into.add(field));
+    plan.scanSignature.filterPredicates?.forEach((predicate) => collectColumns(predicate, into));
+    if (plan.projection) {
+        into.add(plan.projection.column);
+    }
+    columns = into;
+    planColumnsCache.set(plan, columns);
+    return columns;
+};
+/**
+ * Incremental re-execution: updates `previous` for a batch of cell changes
+ * using the operators' `delta` contracts, or returns `undefined` when the
+ * expression (or any change) is not delta-eligible and a rescan is needed.
+ *
+ * Eligible when every plan whose main input is a changed column satisfies
+ * {@link isDeltaCapablePlan} and the changed rows are in its row set. Plans
+ * reading other columns keep their previous result untouched; the outer
+ * expression is re-evaluated over the updated slot values (so
+ * `[price] / SUM{[price]}` re-derives per row from the new total).
+ *
+ * Changes are applied in order, so a batch containing several edits of the
+ * same cell (a→b, b→c) is exact. Row additions / removals and row-set
+ * changes are not cell changes — callers must rescan for those.
+ */
+export const applyValueExpressionDelta = (compiled, previous, changes, config) => {
+    if (changes.length === 0) {
+        return previous;
+    }
+    // A value-read override may transform what the scan saw; the reported raw
+    // old/new values would not match it.
+    if (config.getValue || previous.aggregations.length !== compiled.aggregations.length) {
+        return undefined;
+    }
+    // Observable / clock-dependent expressions re-read history and time on
+    // every execution — there is no accumulator to patch.
+    if (compiled.dependencies.observable || compiled.dependencies.time) {
+        return undefined;
+    }
+    const registry = config.registry ?? SYSTEM_AGGREGATION_CATALOGUE;
+    const changedColumns = new Set(changes.map((change) => change.columnId));
+    const readsChangedColumn = (columns) => {
+        for (const column of changedColumns) {
+            if (columns.has(column)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    const touched = [];
+    for (let index = 0; index < compiled.aggregations.length; index++) {
+        const plan = compiled.aggregations[index];
+        if (!readsChangedColumn(planColumns(plan))) {
+            // Untouched by this batch: the previous slot result stands.
+            continue;
+        }
+        const operator = registry.get(plan.operator.name);
+        if (!operator ||
+            !isDeltaCapablePlan(plan, operator) ||
+            previous.aggregations[index].accumulator === undefined) {
+            return undefined;
+        }
+        // Delta-capable plans read exactly one column (the bare input), so the
+        // change is on the input; the row must be in the plan's row set.
+        const kind = plan.scanSignature.rowSetKind;
+        if (kind !== DEFAULT_ROW_SET_KIND) {
+            const inputField = plan.input.field;
+            for (const change of changes) {
+                if (change.columnId === inputField &&
+                    config.rowSetContainsRow?.(kind, change.rowRef) !== true) {
+                    return undefined;
+                }
+            }
+        }
+        touched.push({ index, operator: operator });
+    }
+    if (touched.length === 0) {
+        // No plan reads a changed column; only the outer expression may (per row).
+        return assembleValueExecutionResult(compiled, previous.aggregations, createLazyBaseContext(config), config);
+    }
+    const aggResults = previous.aggregations.slice();
+    for (const { index, operator } of touched) {
+        const plan = compiled.aggregations[index];
+        const inputField = plan.input.field;
+        const before = previous.aggregations[index];
+        let accumulator = before.accumulator;
+        for (const change of changes) {
+            if (change.columnId !== inputField) {
+                continue;
+            }
+            accumulator = operator.capabilities.delta(accumulator, coerceValue(change.oldValue), coerceValue(change.newValue));
+        }
+        const spec = {
+            params: plan.operator.params,
+            inputType: plan.inputType,
+            hasWeight: false,
+            inputField,
+            groupBy: plan.groupBy,
+        };
+        const value = operator.done ? operator.done(spec, accumulator) : accumulator;
+        aggResults[index] = {
+            value,
+            values: [value],
+            getValueForRow: () => value,
+            rowCount: before.rowCount,
+            accumulator,
+        };
+    }
+    return assembleValueExecutionResult(compiled, aggResults, createLazyBaseContext(config), config);
+};
+const isRootAggregation = (compiled) => {
+    const root = compiled.outerNode;
+    const index = compiled.aggregations.findIndex((plan) => plan.sourceNode === root);
+    return index === -1 ? undefined : index;
+};
+//# sourceMappingURL=execute.js.map