@inflexa-ai/harness 0.45.1 → 0.46.2

package/dist/report-render/chart.js

@@ -25,9 +25,12 @@
  * other value axis keeps the tick values that ECharts computes. A custom series names its renderer as a
  * string, and each consumer of the option binds the name (`chart-renderers.ts`).
  */
+import { textOf } from "../lib/unknown-text.js";
 import { err, ok } from "neverthrow";
 import { channelColumn, channelOrder, channelTransform, } from "../contracts/report-blocks.js";
 import { declaredForColumn } from "../contracts/report-reference.js";
+import { isUnknownArray } from "../lib/unknown-array.js";
+import { parseUnknownRecord } from "../lib/unknown-containers.js";
 import { normalizeEchartSpec } from "../tools/display/normalize-echart-spec.js";
 import { categoryInterval, INTERVAL_RENDERER, LABEL_LINE_SHARE, OUTLINE_RENDERER, VIOLIN_GRID_POINTS } from "./chart-renderers.js";
 import { BAR_VALUE_LABEL_LIMIT, CHART_BODY_PX, CHART_FONT_STACK, CHART_INK, CHART_INLINE_OPTION_BOUND, CHART_PAGE_TEXT_PX, CHART_PAGE_WIDTH_PX, CHART_SLOT_LIMIT, COLOR_SCALE_BAND_PCT, FACET_COLUMNS, FACET_PANEL_LIMIT, FACET_ROW_PX, FOCUS_CHART_COLOR, MUTED_CHART_COLOR, SCATTER_CROWD_OPACITY, SCATTER_CROWD_ROWS, SCATTER_CROWD_SYMBOL_SIZE, SCATTER_HOVER_ROWS, SCATTER_HOVER_SYMBOL_SIZE, SIZE_CHANNEL_RANGE_PX, } from "./design.js";
@@ -35,7 +38,7 @@ import { applyFigureRules, axisNameFields, categoryAxisTitle, categoryName, char
 import { FIGURE_MEMBER_READERS, FIGURE_MODULES, isModuleOnlyType, } from "./figures/index.js";
 import { SHAPED_SCATTER_FIGURE } from "./figures/pca.js";
 import { formatNumberCell, selectNumberKind } from "./number-format.js";
-export { transformColumn };
+export { transformColumn } from "./figures/common.js";
 /**
  * The category values that carry no finding.
  *
@@ -174,7 +177,7 @@ function bodyPxOf(raw, option) {
     const grids = option.grid;
     if (!Array.isArray(grids))
         return CHART_BODY_PX;
-    const panels = grids.filter((grid) => typeof grid === "object" && grid !== null && grid.outerBoundsMode === FACET_BOUNDS_MODE).length;
+    const panels = grids.filter((grid) => parseUnknownRecord(grid)?.outerBoundsMode === FACET_BOUNDS_MODE).length;
     const rows = panels <= 2 ? 1 : Math.ceil(panels / FACET_COLUMNS);
     return CHART_BODY_PX + (rows - 1) * FACET_ROW_PX;
 }
@@ -193,7 +196,7 @@ function blockWidthOf(option, bodyPx) {
         return undefined;
     let width;
     for (const rule of media) {
-        const query = typeof rule === "object" && rule !== null ? rule.query : undefined;
+        const query = parseUnknownRecord(parseUnknownRecord(rule)?.query);
         if (query === undefined || query.maxWidth !== undefined || typeof query.minWidth !== "number" || typeof query.minHeight !== "number")
             continue;
         if (query.minHeight <= bodyPx)
@@ -247,7 +250,7 @@ function chartRender(pass) {
         readsPayload: pass.readsPayload,
         inline: pass.inline,
         bodyPx: pass.bodyPx,
-        ...(widthPx !== undefined ? { widthPx } : {}),
+        widthPx,
     };
 }
 /**
@@ -288,7 +291,7 @@ function describesLead(series, collector) {
     return (composed !== undefined &&
         composed.length === described &&
         described < series.length &&
-        composed.every((name, index) => series[index].name === name));
+        composed.every((name, index) => parseUnknownRecord(series[index])?.name === name));
 }
 /**
  * The quick path of one block that draws one point for one row, or `undefined` for every other block.
@@ -319,12 +322,12 @@ function perRowQuickPath(block, opts) {
 function sourcedOption(option, series, collector, key) {
     const source = {
         payload: key,
-        ...(collector.rule !== undefined ? { rule: collector.rule } : {}),
+        rule: collector.rule,
         series: collector.series,
     };
     return {
         ...option,
-        series: series.map((entry, index) => (index < collector.series.length ? { ...entry, data: [] } : entry)),
+        series: series.map((entry, index) => (index < collector.series.length ? { ...parseUnknownRecord(entry), data: [] } : entry)),
         [CHART_SOURCE_MEMBER]: source,
     };
 }
@@ -409,8 +412,8 @@ function deriveRaw(block, rows, columns, collector, inputs, opts) {
     return deriveBase({
         ...quick.value.block,
         meanings,
-        ...(block.focus !== undefined ? { focus: block.focus } : {}),
-        ...(stackedFacet !== undefined ? { facet: channelColumn(stackedFacet) } : {}),
+        focus: block.focus,
+        facet: stackedFacet === undefined ? undefined : channelColumn(stackedFacet),
     }, quick.value.rows, columns);
 }
 /** The members that the canonical figures add. A chart type with no figure module reads none of them. */
@@ -435,10 +438,32 @@ function declaresMember(block, member) {
     }
 }
 /** Each member that one block declares, in the order of the grammar. */
+const ENCODING_KEYS = [
+    "x",
+    "y",
+    "group",
+    "value",
+    "label",
+    "color",
+    "size",
+    "low",
+    "high",
+    "facet",
+    "shape",
+    "p",
+    "censor",
+    "risk",
+    "hit",
+    "metric",
+    "tracks",
+];
+function isEncodingKey(key) {
+    return ENCODING_KEYS.some((member) => member === key);
+}
 function declaredMembers(block) {
     const members = [];
     for (const key of Object.keys(block.encoding ?? {})) {
-        if (block.encoding?.[key] !== undefined)
+        if (isEncodingKey(key) && block.encoding?.[key] !== undefined)
             members.push(key);
     }
     for (const member of ["statistics", "track", "trees", "focus"]) {
@@ -450,7 +475,7 @@ function declaredMembers(block) {
 /** The sentence that names the chart types that read one member that the canonical figures add. */
 function readersSentence(member) {
     const readers = FIGURE_MEMBER_READERS[member];
-    const list = readers.length <= 2 ? readers.join(" and ") : `${readers.slice(0, -1).join(", ")}, and ${readers[readers.length - 1]}`;
+    const list = readers.length <= 2 ? readers.join(" and ") : `${readers.slice(0, -1).join(", ")}, and ${String(readers[readers.length - 1])}`;
     switch (member) {
         case "statistics":
             return `The statistics are legal on the ${list} charts.`;
@@ -516,10 +541,10 @@ function deriveFigure(block, chartType, figure, rows, columns, collector, inputs
         blockId: block.id,
         labels,
         meanings,
-        ...(columns !== undefined ? { columns } : {}),
+        columns,
         statistics: statistics.value,
-        ...(track.value !== undefined ? { track: track.value } : {}),
-        ...(trees.value !== undefined ? { trees: trees.value } : {}),
+        track: track.value,
+        trees: trees.value,
         textPx: CHART_PAGE_TEXT_PX,
         compose: (composition, { keepsRowsInline, ...extras } = {}) => {
             // A composition with no collector describes no page build, thus the chart keeps its rows inline.
@@ -528,7 +553,7 @@ function deriveFigure(block, chartType, figure, rows, columns, collector, inputs
             if (described !== undefined && option.isOk()) {
                 // The names of the composition output let the pass tell it apart from a series that the
                 // figure adds after it.
-                described.composed = Array.isArray(option.value.series) ? option.value.series.map((entry) => String(entry.name)) : [];
+                described.composed = Array.isArray(option.value.series) ? option.value.series.map((entry) => textOf(parseUnknownRecord(entry)?.name)) : [];
             }
             return option;
         },
@@ -552,10 +577,18 @@ function figureStatistics(block, values) {
     if (values === undefined || values.length !== declared.length) {
         return err(missingPart(block.id, `The chart declares ${declared.length} statistics, and its value entry carries ${values?.length ?? 0}.`));
     }
-    return ok(declared.map((statistic, index) => ({
+    const pairs = [];
+    for (const [index, statistic] of declared.entries()) {
+        const resolved = values[index];
+        if (resolved === undefined) {
+            return err(missingPart(block.id, `The chart declares ${declared.length} statistics, and its value entry carries ${values.length}.`));
+        }
+        pairs.push([statistic, resolved]);
+    }
+    return ok(pairs.map(([statistic, resolved]) => ({
         label: statistic.label,
-        value: values[index].value,
-        text: statisticText(values[index].value, statistic.value.locator.column, statistic.value.unit),
+        value: resolved.value,
+        text: statisticText(resolved.value, statistic.value.locator.column, statistic.value.unit),
     })));
 }
 /** The resolved track of one block, or `undefined` for a block that declares none. An entry with no track refuses. */
@@ -568,11 +601,11 @@ function figureTrack(block, value) {
     }
     return ok({
         rows: value.rows,
-        ...(value.columns !== undefined ? { columns: value.columns } : {}),
+        columns: value.columns,
         start: declared.start,
         end: declared.end,
         label: declared.label,
-        ...(declared.length !== undefined ? { length: declared.length } : {}),
+        length: declared.length,
         labels: declared.binding.columnLabels,
         meanings: declared.binding.columnMeanings,
     });
@@ -596,7 +629,7 @@ function figureTrees(block, values) {
         }
         trees[axis] = {
             rows: value.rows,
-            ...(value.columns !== undefined ? { columns: value.columns } : {}),
+            columns: value.columns,
             parent: tree.parent,
             child: tree.child,
             height: tree.height,
@@ -741,19 +774,19 @@ function deriveAsComposition(blockId, chartType, encoding, rows, columns, labels
                 encoding: {
                     x: x.value,
                     y: y.value,
-                    ...(encoding.group !== undefined ? { group: encoding.group } : {}),
-                    ...(encoding.label !== undefined ? { label: encoding.label } : {}),
-                    ...(encoding.color !== undefined ? { color: encoding.color } : {}),
-                    ...(encoding.size !== undefined ? { size: encoding.size } : {}),
-                    ...(encoding.low !== undefined ? { low: encoding.low } : {}),
-                    ...(encoding.high !== undefined ? { high: encoding.high } : {}),
+                    group: encoding.group,
+                    label: encoding.label,
+                    color: encoding.color,
+                    size: encoding.size,
+                    low: encoding.low,
+                    high: encoding.high,
                 },
                 // The caller refused an orientation on every type but the bar, thus the form here is a bar
                 // wherever one arrives. The arrangement crosses onto the series, and no name channel loses it.
-                ...(orientation !== undefined ? { orientation } : {}),
+                orientation,
             },
         ],
-        ...(encoding.facet !== undefined ? { facet: encoding.facet } : {}),
+        facet: encoding.facet,
     };
     return deriveComposition(blockId, composition, rows, columns, labels, extras);
 }
@@ -820,18 +853,18 @@ const CHANNELS = ["x", "y", "group", "value"];
  * without a value drops, thus no substitute value ever appears.
  */
 function deriveTransformedRows(rows, derived) {
-    const values = derived.map((entry) => transformColumn(rows, entry.column, entry.transform));
+    const columns = derived.map((entry) => ({ name: entry.name, values: transformColumn(rows, entry.column, entry.transform) }));
     const out = [];
-    for (let index = 0; index < rows.length; index += 1) {
-        const next = { ...rows[index] };
+    for (const [index, row] of rows.entries()) {
+        const next = { ...row };
         let complete = true;
-        for (let slot = 0; slot < derived.length; slot += 1) {
-            const value = values[slot][index];
+        for (const column of columns) {
+            const value = column.values[index] ?? null;
             if (value === null) {
                 complete = false;
                 break;
             }
-            next[derived[slot].name] = value;
+            next[column.name] = value;
         }
         if (complete)
             out.push(next);
@@ -875,19 +908,23 @@ function deriveBar(block, rows, columns, mode) {
         if (focused.isErr())
             return err(focused.error);
         const focus = focused.value;
-        const bars = groupedSeries(rows, group, (groupRows, name) => ({
-            type: "bar",
-            ...(name !== undefined ? { name: categoryName(name) } : {}),
-            ...categoryStyle(name, focus),
-            barGap: 0,
-            barCategoryGap: BAR_CATEGORY_GAP,
-            data: groupRows.map((row) => {
-                const pair = horizontal ? [row[y], categoryCell(row[x])] : [categoryCell(row[x]), row[y]];
-                // A bar with no group reads the focus over its own categories, thus each item carries its color.
-                const color = group === undefined ? focusColor(focus, row[x]) : undefined;
-                return color === undefined ? pair : { value: pair, itemStyle: { color } };
-            }),
-        }));
+        const bars = groupedSeries(rows, group, (groupRows, name) => {
+            const bar = {
+                type: "bar",
+                ...categoryStyle(name, focus),
+                barGap: 0,
+                barCategoryGap: BAR_CATEGORY_GAP,
+                data: groupRows.map((row) => {
+                    const pair = horizontal ? [row[y], categoryCell(row[x])] : [categoryCell(row[x]), row[y]];
+                    // A bar with no group reads the focus over its own categories, thus each item carries its color.
+                    const color = group === undefined ? focusColor(focus, row[x]) : undefined;
+                    return color === undefined ? pair : { value: pair, itemStyle: { color } };
+                }),
+            };
+            if (name !== undefined)
+                bar.name = categoryName(name);
+            return bar;
+        });
         series = withValueLabels(bars, horizontal, (cell) => valueLabelText(y, cell, block.meanings));
     }
     else {
@@ -899,7 +936,12 @@ function deriveBar(block, rows, columns, mode) {
             return err(stacked.error);
         series = stacked.value;
     }
-    const valueAxis = { type: "value", ...(mode === "normalized" ? { min: 0, max: 1 } : {}), ...labelRoom(series, horizontal) };
+    const valueAxis = { type: "value" };
+    if (mode === "normalized") {
+        valueAxis.min = 0;
+        valueAxis.max = 1;
+    }
+    Object.assign(valueAxis, labelRoom(series, horizontal));
     if (horizontal) {
         return ok({
             xAxis: { ...valueAxis, ...xAxisName(axisTitle(block.labels, y)) },
@@ -1009,7 +1051,7 @@ function deriveStackedFacets(block, rows, columns, x, y, categories, normalized,
             let negative = 0;
             for (const entry of panel.value) {
                 // `stackedSeries` gives each series one part or null for each category, in category order.
-                const part = toNumber(entry.data[index]);
+                const part = toNumber(isUnknownArray(entry.data) ? entry.data[index] : undefined);
                 if (part === null)
                     continue;
                 if (part > 0)
@@ -1076,13 +1118,23 @@ function derivePointForm(block, rows, columns, form) {
     const xText = xAxis.value.type === "category";
     const yText = yAxis.value.type === "category";
     const pairOf = (row) => [xText ? categoryCell(row[x]) : row[x], yText ? categoryCell(row[y]) : row[y]];
-    const series = groupedSeries(rows, group, (groupRows, name) => ({
-        type: form,
-        ...(name !== undefined ? { name: categoryName(name) } : {}),
-        ...categoryStyle(name, focused.value),
-        ...(form === "line" ? { showSymbol: false } : { large: true, largeThreshold: 2000 }),
-        data: form === "line" ? sortByX(groupRows.map(pairOf), places) : groupRows.map(pairOf),
-    }));
+    const series = groupedSeries(rows, group, (groupRows, name) => {
+        const entry = {
+            type: form,
+            ...categoryStyle(name, focused.value),
+            data: form === "line" ? sortByX(groupRows.map(pairOf), places) : groupRows.map(pairOf),
+        };
+        if (name !== undefined)
+            entry.name = categoryName(name);
+        if (form === "line") {
+            entry.showSymbol = false;
+        }
+        else {
+            entry.large = true;
+            entry.largeThreshold = 2000;
+        }
+        return entry;
+    });
     return ok({ xAxis: xAxis.value, yAxis: yAxis.value, series });
 }
 /**
@@ -1158,22 +1210,21 @@ function deriveBox(block, rows, columns) {
         return err(focused.error);
     const series = [];
     const buckets = slotBuckets(rows, x, y, groupColumn);
-    const valuesOf = groups.map((group) => categories.map((category) => buckets.get(slotKey(group.name, category)) ?? []));
-    const pointed = drawsDistributionPoints(valuesOf.flat());
+    const lanes = groups.map((group) => ({ name: group.name, values: categories.map((category) => buckets.get(slotKey(group.name, category)) ?? []) }));
+    const pointed = drawsDistributionPoints(lanes.flatMap((lane) => lane.values));
     // The axis jitter centers each point on its category and not on its slot, thus a grouped box places its
     // points on the slot axis.
     const grouped = groups.length > 1;
     const points = [];
     const slotted = [];
-    for (const [place, group] of groups.entries()) {
-        const color = focusColor(focused.value, group.name);
+    for (const [place, lane] of lanes.entries()) {
+        const color = focusColor(focused.value, lane.name);
         const slot = boxSlot(place, groups.length);
         const boxData = [];
         const outliers = [];
         const slotPointList = [];
         const medians = [];
-        for (let index = 0; index < categories.length; index++) {
-            const values = valuesOf[place][index];
+        for (const [index, values] of lane.values.entries()) {
             if (pointed && grouped)
                 slotPointList.push(...slotPoints(values, index, slot));
             else if (pointed) {
@@ -1195,30 +1246,34 @@ function deriveBox(block, rows, columns) {
                 outliers.push([index, outlier]);
             }
         }
-        series.push({
+        const box = {
             type: "boxplot",
-            ...(group.name !== undefined ? { name: categoryName(group.name) } : {}),
             // A box draws its median in the border color, thus a focus colors the border and never the fill.
-            ...(color !== undefined ? { itemStyle: { borderColor: color } } : {}),
+            itemStyle: { borderColor: color },
             data: boxData,
-        });
+        };
+        if (lane.name !== undefined)
+            box.name = categoryName(lane.name);
+        series.push(box);
         // The outlier scatter pairs with its box series, thus it only appears when an outlier exists. A box with
         // no group takes no palette slot by name, thus its outliers take the ink of the points.
         if (outliers.length > 0) {
-            const outlierColor = color ?? (group.name === undefined ? CHART_INK : undefined);
-            series.push({
+            const outlierColor = color ?? (lane.name === undefined ? CHART_INK : undefined);
+            const outlierMarks = {
                 type: "scatter",
-                ...(group.name !== undefined ? { name: categoryName(group.name) } : {}),
-                ...(outlierColor !== undefined ? { itemStyle: { color: outlierColor } } : {}),
+                itemStyle: { color: outlierColor },
                 symbolSize: 4,
                 data: outliers,
-            });
+            };
+            if (lane.name !== undefined)
+                outlierMarks.name = categoryName(lane.name);
+            series.push(outlierMarks);
         }
-        const onSlots = slotSeries(group.name === undefined ? undefined : categoryName(group.name), slotPointList, medians, grouped ? color : CHART_INK);
+        const onSlots = slotSeries(lane.name === undefined ? undefined : categoryName(lane.name), slotPointList, medians, grouped ? color : CHART_INK);
         if (onSlots !== undefined)
             slotted.push(onSlots);
     }
-    const pointName = groups[0]?.name;
+    const pointName = lanes[0]?.name;
     if (points.length > 0)
         series.push(pointSeries(points, pointName === undefined ? undefined : categoryName(pointName)));
     series.push(...slotted);
@@ -1226,8 +1281,9 @@ function deriveBox(block, rows, columns) {
         type: "category",
         data: categories,
         ...axisNameFields("x", categoryAxisTitle(block.labels, x)),
-        ...(points.length > 0 ? JITTERED_AXIS : {}),
     };
+    if (points.length > 0)
+        Object.assign(categoryAxis, JITTERED_AXIS);
     return ok({
         xAxis: slotted.length > 0 ? [categoryAxis, slotAxis(categories.length)] : categoryAxis,
         yAxis: { type: "value", ...yAxisName(axisTitle(block.labels, y)) },
@@ -1297,19 +1353,17 @@ function slotSeries(name, points, medians, color) {
         return undefined;
     return {
         ...pointSeries(points, name),
-        itemStyle: { ...(color !== undefined ? { color } : {}), opacity: DISTRIBUTION_POINT_OPACITY },
+        itemStyle: { color, opacity: DISTRIBUTION_POINT_OPACITY },
         xAxisIndex: 1,
-        ...(medians.length > 0
+        markLine: medians.length > 0
             ? {
-                markLine: {
-                    silent: true,
-                    symbol: "none",
-                    label: { show: false },
-                    lineStyle: { width: MEDIAN_LINE_WIDTH_PX, type: "solid", opacity: 1 },
-                    data: medians.map((line) => [...line]),
-                },
+                silent: true,
+                symbol: "none",
+                label: { show: false },
+                lineStyle: { width: MEDIAN_LINE_WIDTH_PX, type: "solid", opacity: 1 },
+                data: medians.map((line) => [...line]),
             }
-            : {}),
+            : undefined,
     };
 }
 /**
@@ -1338,7 +1392,7 @@ const JITTERED_AXIS = { jitter: 24, jitterOverlap: false, jitterMargin: 0 };
 function pointSeries(points, name) {
     return {
         type: "scatter",
-        ...(name !== undefined ? { name } : {}),
+        name,
         silent: true,
         symbolSize: DISTRIBUTION_POINT_SIZE,
         itemStyle: { color: CHART_INK, opacity: DISTRIBUTION_POINT_OPACITY },
@@ -1414,31 +1468,34 @@ function deriveViolin(block, rows, columns) {
     if (focused.isErr())
         return err(focused.error);
     const buckets = slotBuckets(rows, x, y, groupColumn);
-    const shapes = groups.map((group) => categories.flatMap((category, index) => {
-        const shape = violinShape(buckets.get(slotKey(group.name, category)) ?? []);
-        return shape === undefined ? [] : [{ ...shape, category: index }];
+    const lanes = groups.map((group) => ({
+        name: group.name,
+        shapes: categories.flatMap((category, index) => {
+            const shape = violinShape(buckets.get(slotKey(group.name, category)) ?? []);
+            return shape === undefined ? [] : [{ ...shape, category: index }];
+        }),
+        values: categories.map((category) => buckets.get(slotKey(group.name, category)) ?? []),
     }));
     let largest = 0;
-    for (const shape of shapes.flat()) {
+    for (const shape of lanes.flatMap((lane) => lane.shapes)) {
         for (const density of shape.densities)
             largest = Math.max(largest, density);
     }
-    const valuesOf = groups.map((group) => categories.map((category) => buckets.get(slotKey(group.name, category)) ?? []));
-    const pointed = drawsDistributionPoints(valuesOf.flat());
+    const pointed = drawsDistributionPoints(lanes.flatMap((lane) => lane.values));
     // The axis jitter centers each point on its category and not on its slot, thus a grouped violin places its
     // points on the slot axis.
     const grouped = groups.length > 1;
     const slotted = [];
     const series = [];
     const legend = [];
-    for (const [place, group] of groups.entries()) {
-        const name = group.name !== undefined ? categoryName(group.name) : axisTitle(block.labels, y);
+    for (const [place, lane] of lanes.entries()) {
+        const name = lane.name !== undefined ? categoryName(lane.name) : axisTitle(block.labels, y);
         const offset = slotOffset(place, groups.length);
         const slot = violinSlot(place, groups.length);
-        const shaped = new Set(shapes[place].map((shape) => shape.category));
-        const medians = valuesOf[place].flatMap((values, index) => (shaped.has(index) || values.length === 0 ? [] : [medianLine(values, index, slot)]));
-        const slotPointList = pointed && grouped ? valuesOf[place].flatMap((values, index) => slotPoints(values, index, slot)) : [];
-        const color = focusColor(focused.value, group.name);
+        const shaped = new Set(lane.shapes.map((shape) => shape.category));
+        const medians = lane.values.flatMap((values, index) => (shaped.has(index) || values.length === 0 ? [] : [medianLine(values, index, slot)]));
+        const slotPointList = pointed && grouped ? lane.values.flatMap((values, index) => slotPoints(values, index, slot)) : [];
+        const color = focusColor(focused.value, lane.name);
         const onSlots = slotSeries(name, slotPointList, medians, grouped ? color : CHART_INK);
         if (onSlots !== undefined)
             slotted.push(onSlots);
@@ -1449,13 +1506,13 @@ function deriveViolin(block, rows, columns) {
             renderItem: OUTLINE_RENDERER,
             silent: true,
             encode: { x: 0, y: [1, 2] },
-            ...(color !== undefined ? { itemStyle: { color } } : nullCategoryStyle(group.name)),
-            data: shapes[place].map((shape) => [
+            itemStyle: color !== undefined ? { color } : nullCategoryStyle(lane.name).itemStyle,
+            data: lane.shapes.map((shape) => [
                 shape.category,
                 shape.grid[0],
                 shape.grid[shape.grid.length - 1],
                 offset,
-                ...shape.grid.flatMap((value, point) => [roundWidth(largest > 0 ? (shape.densities[point] / largest) * halfWidth : 0), value]),
+                ...shape.grid.flatMap((value, point) => [roundWidth(largest > 0 ? ((shape.densities[point] ?? 0) / largest) * halfWidth : 0), value]),
             ]),
         });
         series.push({
@@ -1464,13 +1521,13 @@ function deriveViolin(block, rows, columns) {
             renderItem: INTERVAL_RENDERER,
             silent: true,
             encode: { x: 0, y: [1, 2, 3] },
-            data: shapes[place].map((shape) => [shape.category, shape.median, shape.q1, shape.q3, 1, offset, 1]),
+            data: lane.shapes.map((shape) => [shape.category, shape.median, shape.q1, shape.q3, 1, offset, 1]),
         });
         legend.push(name);
     }
     const points = [];
     if (pointed && !grouped) {
-        for (const [index, values] of (valuesOf[0] ?? []).entries()) {
+        for (const [index, values] of (lanes[0]?.values ?? []).entries()) {
             for (const value of values)
                 points.push([index, value]);
         }
@@ -1482,8 +1539,9 @@ function deriveViolin(block, rows, columns) {
         type: "category",
         data: categories,
         ...axisNameFields("x", categoryAxisTitle(block.labels, x)),
-        ...(points.length > 0 ? JITTERED_AXIS : {}),
     };
+    if (points.length > 0)
+        Object.assign(categoryAxis, JITTERED_AXIS);
     return ok({
         xAxis: slotted.length > 0 ? [categoryAxis, slotAxis(categories.length)] : categoryAxis,
         yAxis: { type: "value", scale: true, ...yAxisName(axisTitle(block.labels, y)) },
@@ -1650,7 +1708,8 @@ function deriveComposition(blockId, composition, rows, columns, labels, extras =
             return err(series.error);
         resolved.push(series.value);
     }
-    if (resolved.length === 0) {
+    const first = resolved[0];
+    if (first === undefined) {
         // The schema holds a composition to one series at least. The guard states the same rule for a
         // value that reaches the renderer without a parse, because the axes come from the first series.
         return err(problem(blockId, "The composition carries no series."));
@@ -1659,7 +1718,7 @@ function deriveComposition(blockId, composition, rows, columns, labels, extras =
     const labeled = pointLabelRows(blockId, annotations, rows, columns, plottedRows(resolved, rows.length));
     if (labeled.isErr())
         return err(labeled.error);
-    const focused = focusSet(blockId, extras.focus, rows.length, compositionCategories(resolved, rows.length));
+    const focused = focusSet(blockId, extras.focus, rows.length, compositionCategories(resolved));
     if (focused.isErr())
         return err(focused.error);
     if (collector !== undefined && classification !== undefined) {
@@ -1686,10 +1745,9 @@ function deriveComposition(blockId, composition, rows, columns, labels, extras =
         density: scatterDensity(rows.length),
         annotations,
         // The axes come from the first series, thus its order sorts the shared x axis of every series.
-        orderedX: resolved[0].x.order !== undefined,
+        orderedX: first.x.order !== undefined,
         colorOnTop: extras.colorOnTop === true,
     };
-    const first = resolved[0];
     const axes = compositionAxes(context, first, composition.axes);
     if (axes.isErr())
         return err(axes.error);
@@ -1706,21 +1764,26 @@ function deriveComposition(blockId, composition, rows, columns, labels, extras =
     const series = labeledSeries(context, emitted.value, horizontal);
     const room = first.declared.form === "bar" ? labelRoom(series, horizontal) : {};
     const colored = emitted.value.some((entry) => entry.entry?.color !== undefined);
-    const grid = {
-        // A horizontal bar draws its category names as y labels, thus the grid must hold them.
-        ...(isHorizontalBar(first.declared) ? LABEL_CONTAINING_GRID : {}),
-        // A continuous color draws its scale at the right edge, thus the grid leaves that band free.
-        ...(colored ? { right: COLOR_SCALE_GRID_RIGHT } : {}),
-    };
-    return ok({
+    const grid = {};
+    // A continuous color draws its scale at the right edge, thus the grid leaves that band free.
+    if (colored)
+        grid.right = COLOR_SCALE_GRID_RIGHT;
+    // A horizontal bar draws its category names as y labels, thus the grid must hold them.
+    if (isHorizontalBar(first.declared))
+        Object.assign(grid, LABEL_CONTAINING_GRID);
+    const panel = {
         tooltip: named ? { ...NAMED_TOOLTIP } : { ...PLAIN_TOOLTIP },
         xAxis: horizontal ? { ...axes.value.xAxis, ...room } : axes.value.xAxis,
         yAxis: horizontal ? axes.value.yAxis : { ...axes.value.yAxis, ...room },
         series,
-        ...(maps.length > 0 ? { visualMap: maps } : {}),
-        ...(emitted.value.some((entry) => entry.auxiliary) ? { legend: legendOf(drawnNames(emitted.value)) } : {}),
-        ...(Object.keys(grid).length > 0 ? { grid } : {}),
-    });
+    };
+    if (maps.length > 0)
+        panel.visualMap = maps;
+    if (emitted.value.some((entry) => entry.auxiliary))
+        panel.legend = legendOf(drawnNames(emitted.value));
+    if (Object.keys(grid).length > 0)
+        panel.grid = grid;
+    return ok(panel);
 }
 /** The stack prefix of a band. A facet panel adds its own place, thus two panels never stack each other. */
 const BAND_STACK_PREFIX = "band-";
@@ -1804,14 +1867,13 @@ function compositionFault(composition, focus) {
  * The categories that a focus of one composition can name: the values of each group channel, and the `x`
  * values of each bar series that splits by no group.
  */
-function compositionCategories(resolved, rowCount) {
+function compositionCategories(resolved) {
     const categories = [];
     for (const entry of resolved) {
         const channel = entry.group ?? (entry.declared.form === "bar" ? entry.x : undefined);
         if (channel === undefined)
             continue;
-        for (let index = 0; index < rowCount; index += 1) {
-            const value = channel.values[index];
+        for (const value of channel.values) {
             if (value !== null)
                 categories.push(value);
         }
@@ -1845,22 +1907,23 @@ function composePanel(context, resolved, members, axes, stackPrefix) {
         emitted.push(...built.value);
     }
     const marks = markMembers(context.annotations);
-    const target = markCarrier(emitted);
-    if (Object.keys(marks).length > 0 && target >= 0) {
-        emitted[target] = { ...emitted[target], option: { ...emitted[target].option, ...marks } };
+    const carrier = markCarrier(emitted);
+    if (Object.keys(marks).length > 0 && carrier !== undefined) {
+        const target = emitted.indexOf(carrier);
+        emitted[target] = { ...carrier, option: { ...carrier.option, ...marks } };
     }
     return ok(emitted);
 }
 /** The option of each emitted series, with the value label of each bar of a small bar chart. */
 function labeledSeries(context, emitted, horizontal) {
     return withValueLabels(emitted.map((entry) => entry.option), horizontal, (cell, index) => {
-        const value = emitted[index].entry?.y;
+        const value = emitted[index]?.entry?.y;
         return value === undefined ? String(cell) : valueLabelText(value.transformed ? value.name : value.column, cell, context.meanings);
-    }, (index) => emitted[index].entry?.low === undefined);
+    }, (index) => emitted[index]?.entry?.low === undefined);
 }
 /** The names of the drawn series, in series order. An auxiliary series names no entry of its own. */
 function drawnNames(emitted) {
-    return emitted.filter((entry) => !entry.auxiliary).map((entry) => String(entry.option.name));
+    return emitted.filter((entry) => !entry.auxiliary).map((entry) => textOf(entry.option.name));
 }
 /**
  * The visual maps of one composition: one map over the continuous color, and one map over the symbol size
@@ -1912,8 +1975,8 @@ function visualMaps(context, resolved, emitted) {
             show: false,
             seriesIndex,
             dimension,
-            min: sizes.length > 0 ? lowest(sizes) : 0,
-            max: sizes.length > 0 ? highest(sizes) : 1,
+            min: lowest(sizes) ?? 0,
+            max: highest(sizes) ?? 1,
             inRange: { symbolSize: [...SIZE_CHANNEL_RANGE_PX] },
         });
     }
@@ -1926,11 +1989,12 @@ function visualMaps(context, resolved, emitted) {
 function drawnMembers(emitted, seriesIndex, dimension) {
     const members = [];
     for (const index of seriesIndex) {
-        const data = emitted[index].option.data;
+        const data = emitted[index]?.option.data;
         if (!Array.isArray(data))
             continue;
         for (const item of data) {
-            const value = Array.isArray(item) ? item : typeof item === "object" && item !== null ? item.value : undefined;
+            const fields = parseUnknownRecord(item);
+            const value = Array.isArray(item) ? item : fields?.value;
             const member = Array.isArray(value) ? toNumber(value[dimension]) : null;
             if (member !== null)
                 members.push(member);
@@ -1938,20 +2002,22 @@ function drawnMembers(emitted, seriesIndex, dimension) {
     }
     return members;
 }
-/** The smallest of some values, read in one pass. */
+/** The smallest of some values, or `undefined` for no value. */
 function lowest(values) {
-    let min = values[0];
-    for (const value of values)
-        if (value < min)
+    let min;
+    for (const value of values) {
+        if (min === undefined || value < min)
             min = value;
+    }
     return min;
 }
-/** The largest of some values, read in one pass. */
+/** The largest of some values, or `undefined` for no value. */
 function highest(values) {
-    let max = values[0];
-    for (const value of values)
-        if (value > max)
+    let max;
+    for (const value of values) {
+        if (max === undefined || value > max)
             max = value;
+    }
     return max;
 }
 /**
@@ -1968,9 +2034,9 @@ function intervalAlongX(entry, axes) {
 }
 /** The place of each category of one axis, keyed by the text of the category, or `undefined` for a value axis. */
 function categoryPlaces(axis) {
-    if (axis.type !== "category" || !Array.isArray(axis.data))
+    if (axis.type !== "category" || !isUnknownArray(axis.data))
         return undefined;
-    return new Map(axis.data.map((category, place) => [String(category), place]));
+    return new Map(axis.data.map((category, place) => [textOf(category), place]));
 }
 /**
  * The interval series of one runtime series: one custom series with the `interval` renderer, after the series
@@ -2039,6 +2105,10 @@ function deriveFacets(context, facet, columns, resolved, axes) {
     if (context.collector !== undefined) {
         context.collector.failed = true;
     }
+    const first = resolved[0];
+    if (first === undefined) {
+        return err(problem(context.blockId, "The composition carries no series."));
+    }
     const split = splitByChannel(context.rows, channel.value);
     if (split.length > FACET_PANEL_LIMIT) {
         return err(problem(context.blockId, `The facet splits the table into ${split.length} panels. A facet holds ${FACET_PANEL_LIMIT} panels at most, thus a table of fewer groups serves the reader.`));
@@ -2055,24 +2125,26 @@ function deriveFacets(context, facet, columns, resolved, axes) {
             emitted.push({ ...entry, option: { ...entry.option, xAxisIndex: place, yAxisIndex: place } });
         }
     }
-    const labeledPanels = labeledSeries(context, emitted, isHorizontalBar(resolved[0].declared));
-    const labeled = resolved[0].declared.form === "bar" && Object.keys(labelRoom(labeledPanels, isHorizontalBar(resolved[0].declared))).length > 0;
-    const shared = sharedAxes(context, resolved, axes, labeled);
+    const labeledPanels = labeledSeries(context, emitted, isHorizontalBar(first.declared));
+    const labeled = first.declared.form === "bar" && Object.keys(labelRoom(labeledPanels, isHorizontalBar(first.declared))).length > 0;
+    const shared = sharedAxes(context, resolved, axes, labeled, isHorizontalBar(first.declared));
     // A continuous color draws its scale at the right edge, thus the panels leave that band free.
     const scaleBand = emitted.some((entry) => entry.entry?.color !== undefined) ? COLOR_SCALE_BAND_PCT : 0;
     const layout = facetLayout(panels.map((panel) => panel.name), shared, legendOf(drawnNames(emitted)), scaleBand);
     const named = resolved.some((entry) => entry.label !== undefined) || context.labeled.size > 0;
     const maps = visualMaps(context, resolved, emitted);
-    return ok({
+    const panel = {
         tooltip: named ? { ...NAMED_TOOLTIP } : { ...PLAIN_TOOLTIP },
         grid: layout.grid,
         xAxis: layout.xAxis,
         yAxis: layout.yAxis,
         series: labeledPanels,
         graphic: layout.graphic,
-        ...(maps.length > 0 ? { visualMap: maps } : {}),
         legend: layout.legend,
-    });
+    };
+    if (maps.length > 0)
+        panel.visualMap = maps;
+    return ok(panel);
 }
 /**
  * The layout of the panels of a facet, one panel for each name in order.
@@ -2140,12 +2212,12 @@ function facetLayout(names, shared, legend, scaleBand) {
  * turned label still covers its neighbor. `widthPx` is the panel width on the page, and an x axis alone states it.
  */
 function panelAxis(axis, widthPx) {
-    const label = typeof axis.axisLabel === "object" && axis.axisLabel !== null ? axis.axisLabel : {};
+    const label = parseUnknownRecord(axis.axisLabel) ?? {};
     const base = { ...withoutName(axis), splitNumber: FACET_SPLIT_NUMBER };
-    if (axis.type !== "category" || !Array.isArray(axis.data))
+    if (axis.type !== "category" || !isUnknownArray(axis.data))
         return { ...base, axisLabel: { ...label, hideOverlap: true } };
     const turn = widthPx === undefined || label.rotate !== undefined ? undefined : categoryTurn(axis.data, widthPx);
-    return { ...base, axisLabel: { ...label, interval: 0, ...(turn !== undefined ? { rotate: turn } : {}) } };
+    return { ...base, axisLabel: { ...label, interval: 0, rotate: turn } };
 }
 /** The width of one character of the chart text, as a share of the text size. */
 const LABEL_CHARACTER_SHARE = 0.6;
@@ -2178,30 +2250,36 @@ function categoryTurn(categories, widthPx) {
 function thinnedLabels(option) {
     if (option.xAxis === undefined)
         return option;
-    let thinned = false;
     const thin = (axis) => {
-        if (typeof axis !== "object" || axis === null || Array.isArray(axis))
+        const fields = parseUnknownRecord(axis);
+        if (fields === undefined)
             return axis;
-        const fields = axis;
-        const label = typeof fields.axisLabel === "object" && fields.axisLabel !== null ? fields.axisLabel : {};
-        if (fields.type !== "category" || !Array.isArray(fields.data) || label.rotate !== 90 || label.show === false)
+        const label = parseUnknownRecord(fields.axisLabel) ?? {};
+        if (fields.type !== "category" || !isUnknownArray(fields.data) || label.rotate !== 90 || label.show === false)
             return axis;
         const interval = categoryInterval(fields.data.length, CHART_PAGE_TEXT_PX, pagePlotWidth(option.grid, fields));
         if (interval === 0)
             return axis;
-        thinned = true;
         return { ...fields, axisLabel: { ...label, interval } };
     };
-    const xAxis = Array.isArray(option.xAxis) ? option.xAxis.map(thin) : thin(option.xAxis);
-    return { ...option, xAxis, ...(thinned && option.tooltip === undefined ? { tooltip: { trigger: "axis" } } : {}) };
+    const declared = option.xAxis;
+    const axes = Array.isArray(declared) ? declared : [declared];
+    const thinnedAxes = axes.map(thin);
+    const thinned = thinnedAxes.some((axis, index) => axis !== axes[index]);
+    const [singleAxis] = thinnedAxes;
+    const xAxis = Array.isArray(declared) ? thinnedAxes : singleAxis;
+    const result = { ...option, xAxis };
+    if (thinned && option.tooltip === undefined)
+        result.tooltip = { trigger: "axis" };
+    return result;
 }
 /**
  * The plot width of the grid of one axis on the page, in pixels. A grid that states its width gives that width,
  * as a facet panel does. Every other grid spans the page chart body less its two side margins.
  */
 function pagePlotWidth(grid, axis) {
-    const entry = Array.isArray(grid) ? grid[typeof axis.gridIndex === "number" ? axis.gridIndex : 0] : grid;
-    const fields = typeof entry === "object" && entry !== null ? entry : {};
+    const entry = isUnknownArray(grid) ? grid[typeof axis.gridIndex === "number" ? axis.gridIndex : 0] : grid;
+    const fields = parseUnknownRecord(entry) ?? {};
     const stated = pagePx(fields.width);
     return stated > 0 ? stated : CHART_PAGE_WIDTH_PX - pagePx(fields.left) - pagePx(fields.right);
 }
@@ -2242,7 +2320,7 @@ function withoutName(axis) {
  * values. A category axis already lists the categories of every row, and a log axis keeps the range of the
  * chart runtime.
  */
-function sharedAxes(context, resolved, axes, labeled) {
+function sharedAxes(context, resolved, axes, labeled, horizontal) {
     const xs = [];
     const ys = [];
     for (const entry of resolved) {
@@ -2268,7 +2346,6 @@ function sharedAxes(context, resolved, axes, labeled) {
             (horizontal ? xs : ys).push(0);
     }
     // The value labels of a bar sit past the bar ends, thus the value axis of the bar takes the label room.
-    const horizontal = isHorizontalBar(resolved[0].declared);
     return { xAxis: sharedRange(axes.xAxis, xs, labeled && horizontal), yAxis: sharedRange(axes.yAxis, ys, labeled && !horizontal) };
 }
 /**
@@ -2278,11 +2355,11 @@ function sharedAxes(context, resolved, axes, labeled) {
  * of a bar chart with labels does on one panel. The zero of a bar stays the end of its side.
  */
 function sharedRange(axis, values, room) {
-    if (axis.type !== "value" || values.length === 0) {
-        return axis;
-    }
     let low = lowest(values);
     let high = highest(values);
+    if (axis.type !== "value" || low === undefined || high === undefined) {
+        return axis;
+    }
     if (room) {
         const span = high - low;
         if (high > 0)
@@ -2363,12 +2440,12 @@ function plottedSeries(entry, axes, meanings) {
     const horizontal = isHorizontalBar(entry.declared);
     const xAxis = horizontal ? axes.yAxis : axes.xAxis;
     const yAxis = horizontal ? axes.xAxis : axes.yAxis;
-    return {
-        ...entry,
-        x: plottedChannel(entry.x, xAxis, meanings),
-        y: plottedChannel(entry.y, yAxis, meanings),
-        ...(entry.y0 !== undefined ? { y0: plottedChannel(entry.y0, yAxis, meanings) } : {}),
-    };
+    const plotted = { ...entry };
+    plotted.x = plottedChannel(entry.x, xAxis, meanings);
+    plotted.y = plottedChannel(entry.y, yAxis, meanings);
+    if (entry.y0 !== undefined)
+        plotted.y0 = plottedChannel(entry.y0, yAxis, meanings);
+    return plotted;
 }
 /**
  * One plotted channel in the form that its axis reads.
@@ -2385,7 +2462,11 @@ function plottedSeries(entry, axes, meanings) {
 function plottedChannel(channel, axis, meanings) {
     if (axis.type === "category") {
         const retyped = channel.values.some((cell) => typeof cell === "number");
-        return { ...channel, values: channel.values.map((cell) => (cell === null ? null : categoryCell(cell))), ...(retyped ? { retyped: true } : {}) };
+        return {
+            ...channel,
+            values: channel.values.map((cell) => (cell === null ? null : (categoryCell(cell) ?? null))),
+            retyped: retyped ? true : undefined,
+        };
     }
     if (channel.transformed || channel.values.some((cell) => cell !== null && isNonNumericString(cell)))
         return channel;
@@ -2474,8 +2555,7 @@ function splitByChannel(rows, group) {
     }
     const buckets = [];
     const byKey = new Map();
-    for (let index = 0; index < rows.length; index += 1) {
-        const value = group.values[index];
+    for (const [index, value] of group.values.entries()) {
         if (value === null)
             continue;
         // The key carries the type of the cell, thus the number `1` and the string `"1"` are two groups.
@@ -2588,20 +2668,28 @@ function collectSource(collector, entry, split, labeled, form, rises) {
         return;
     }
     const flags = split.indices.filter((index) => labeled.has(index));
-    collector.series.push({
-        x,
-        y,
-        ...(color !== undefined ? { color } : {}),
-        ...(size !== undefined ? { size } : {}),
-        ...(group !== undefined ? { group } : {}),
-        ...(split.category === undefined && split.name !== undefined ? { value: split.name } : {}),
-        ...(split.category !== undefined ? { category: split.category } : {}),
-        ...(label !== undefined ? { label } : {}),
-        ...(flags.length > 0 ? { flags } : {}),
-        ...(SORTED_FORMS.has(form) ? { sort: true } : {}),
-        ...(rises ? { rise: true } : {}),
-        ...(isHorizontalBar(entry.declared) ? { swap: true } : {}),
-    });
+    const described = { x, y };
+    if (color !== undefined)
+        described.color = color;
+    if (size !== undefined)
+        described.size = size;
+    if (group !== undefined)
+        described.group = group;
+    if (split.category === undefined && split.name !== undefined)
+        described.value = split.name;
+    if (split.category !== undefined)
+        described.category = split.category;
+    if (label !== undefined)
+        described.label = label;
+    if (flags.length > 0)
+        described.flags = flags;
+    if (SORTED_FORMS.has(form))
+        described.sort = true;
+    if (rises)
+        described.rise = true;
+    if (isHorizontalBar(entry.declared))
+        described.swap = true;
+    collector.series.push(described);
 }
 /**
  * The payload column of one resolved channel, or `undefined` when the payload holds no such column or when the
@@ -2623,10 +2711,11 @@ function columnSource(collector, channel) {
  * no item style, and the theme answers for it.
  */
 function seriesItemStyle(color, form, density) {
-    const fields = {
-        ...(color !== undefined ? { color } : {}),
-        ...(form === "scatter" && density === "crowd" ? { opacity: SCATTER_CROWD_OPACITY } : {}),
-    };
+    const fields = {};
+    if (color !== undefined)
+        fields.color = color;
+    if (form === "scatter" && density === "crowd")
+        fields.opacity = SCATTER_CROWD_OPACITY;
     return Object.keys(fields).length > 0 ? { itemStyle: fields } : {};
 }
 /**
@@ -2640,11 +2729,9 @@ function seriesItemStyle(color, form, density) {
  * then any carrier at all. Each guide reaches the page under every one of the three.
  */
 function markCarrier(emitted) {
-    const drawn = emitted.findIndex((entry) => entry.carriesMarks && !entry.muted && !entry.empty);
-    if (drawn >= 0)
-        return drawn;
-    const colored = emitted.findIndex((entry) => entry.carriesMarks && !entry.muted);
-    return colored >= 0 ? colored : emitted.findIndex((entry) => entry.carriesMarks);
+    return (emitted.find((entry) => entry.carriesMarks && !entry.muted && !entry.empty) ??
+        emitted.find((entry) => entry.carriesMarks && !entry.muted) ??
+        emitted.find((entry) => entry.carriesMarks));
 }
 /**
  * The points of one group. A row whose channel gives no value drops, and no substitute value appears. A wide
@@ -2655,7 +2742,7 @@ function collectPoints(entry, indices) {
     for (const index of indices) {
         const x = entry.x.values[index];
         const y = entry.y.values[index];
-        if (x === null || y === null)
+        if (x === null || x === undefined || y === null || y === undefined)
             continue;
         const point = { index, x, y };
         if (entry.y0 !== undefined) {
@@ -2733,14 +2820,21 @@ function seriesData(entry, points, labeled, horizontal, itemColor) {
             continue;
         }
         itemObjects = true;
-        data.push({
+        const item = {
             value: pair,
-            // A marked point of a series with no label channel takes the x cell as its name. Thus the
-            // `{b}` of the label template and of the tooltip names a cell of the row, and never nothing.
-            ...(named || marked ? { name: named ? String(label) : String(point.x) } : {}),
-            ...(color !== undefined ? { itemStyle: { color } } : {}),
-            ...(marked ? { label: { ...POINT_LABEL } } : {}),
-        });
+        };
+        // A marked point of a series with no label channel takes the x cell as its name. Thus the
+        // `{b}` of the label template and of the tooltip names a cell of the row, and never nothing.
+        if (named || marked) {
+            item.name = named ? String(label) : String(point.x);
+        }
+        if (color !== undefined) {
+            item.itemStyle = { color };
+        }
+        if (marked) {
+            item.label = { ...POINT_LABEL };
+        }
+        data.push(item);
     }
     return { data, itemObjects };
 }
@@ -2806,13 +2900,19 @@ function formOptions(form, density, perPoint) {
             return { step: "end", showSymbol: false };
         case "area":
             return { showSymbol: false, areaStyle: {} };
-        case "scatter":
-            return {
-                ...(density === "normal" ? {} : { symbolSize: density === "crowd" ? SCATTER_CROWD_SYMBOL_SIZE : SCATTER_HOVER_SYMBOL_SIZE }),
-                // The large path draws a simplified point in one fill, and it drops a per-item style. Thus a
-                // series whose items carry a name, a label, a color, or a size keeps the normal path.
-                ...(perPoint ? {} : { large: true, largeThreshold: LARGE_SCATTER_THRESHOLD }),
-            };
+        case "scatter": {
+            const scatter = {};
+            if (density !== "normal") {
+                scatter.symbolSize = density === "crowd" ? SCATTER_CROWD_SYMBOL_SIZE : SCATTER_HOVER_SYMBOL_SIZE;
+            }
+            // The large path draws a simplified point in one fill, and it drops a per-item style. Thus a
+            // series whose items carry a name, a label, a color, or a size keeps the normal path.
+            if (!perPoint) {
+                scatter.large = true;
+                scatter.largeThreshold = LARGE_SCATTER_THRESHOLD;
+            }
+            return scatter;
+        }
     }
 }
 /**
@@ -2869,15 +2969,16 @@ function pointLabelRows(blockId, annotations, rows, columns, plotted) {
  */
 function topRows(rows, column, order, n, plotted) {
     const ranked = [];
-    for (let index = 0; index < rows.length; index += 1) {
-        if (plotted.has(index) && rows[index][column] !== undefined)
-            ranked.push(index);
+    for (const [index, row] of rows.entries()) {
+        const cell = row[column];
+        if (plotted.has(index) && cell !== undefined)
+            ranked.push({ index, cell });
     }
     ranked.sort((a, b) => {
-        const compared = compareCell(rows[a][column], rows[b][column]);
+        const compared = compareCell(a.cell, b.cell);
         return order === "asc" ? compared : -compared;
     });
-    return ranked.slice(0, n);
+    return ranked.slice(0, n).map((entry) => entry.index);
 }
 /**
  * The mark members of the annotations.
@@ -2902,10 +3003,12 @@ function markMembers(annotations) {
             ]);
         }
     }
-    return {
-        ...(lines.length > 0 ? { markLine: guideMarkLine(lines) } : {}),
-        ...(areas.length > 0 ? { markArea: { silent: true, data: areas } } : {}),
-    };
+    const marks = {};
+    if (lines.length > 0)
+        marks.markLine = guideMarkLine(lines);
+    if (areas.length > 0)
+        marks.markArea = { silent: true, data: areas };
+    return marks;
 }
 /**
  * The label of one mark member. The text is a constant of the annotation, and never a template.
@@ -2914,10 +3017,11 @@ function markMembers(annotations) {
  * its own default, and a member of either kind that states nothing gives the same bytes as before.
  */
 function markLabel(label, position) {
-    const fields = {
-        ...(label !== undefined ? { formatter: label } : {}),
-        ...(position !== undefined ? { position } : {}),
-    };
+    const fields = {};
+    if (label !== undefined)
+        fields.formatter = label;
+    if (position !== undefined)
+        fields.position = position;
     return Object.keys(fields).length > 0 ? { label: fields } : {};
 }
 /** The mark key of one axis. A mark member names `xAxis` or `yAxis`, and the constant that sits on it. */
@@ -3014,13 +3118,13 @@ function compositionAxis(context, channel, axis, declared, preset) {
     if (base.type !== "category") {
         return err(problem(context.blockId, valueAxisOrderFault(channel.column)));
     }
-    const ordered = orderChannel(context, channel, base.data);
+    const ordered = orderChannel(context, channel, isUnknownArray(base.data) ? base.data : []);
     return ordered.map((data) => ({ ...base, data }));
 }
 /** Sort the categories of one composition channel by its order, or keep them where it declares none. */
 function orderChannel(context, channel, categories) {
     const order = channel.order;
-    return orderCategories(context.blockId, context.rows.length, (index) => channel.values[index], categories, order, (index) => (order === undefined ? undefined : context.rows[index][order.by]));
+    return orderCategories(context.blockId, context.rows.length, (index) => channel.values[index], categories, order, (index) => (order === undefined ? undefined : context.rows[index]?.[order.by]));
 }
 // ── The shared building blocks ──────────────────────────────────────────────
 /**
@@ -3096,7 +3200,7 @@ function orderedAxis(blockId, rows, column, axis, titles, order, categorical) {
     if (inferred.type !== "category") {
         return err(problem(blockId, valueAxisOrderFault(column)));
     }
-    const sorted = orderCategories(blockId, rows.length, (index) => String(rows[index][column]), inferred.data, order, (index) => rows[index][order.by]);
+    const sorted = orderCategories(blockId, rows.length, (index) => String(rows[index]?.[column]), isUnknownArray(inferred.data) ? inferred.data : [], order, (index) => rows[index]?.[order.by]);
     return sorted.map((data) => ({ ...inferred, data }));
 }
 /** The refusal of an order on a channel whose axis draws values. */
@@ -3134,24 +3238,26 @@ function focusSet(blockId, focus, rowCount, categories) {
  * no function and the plotted value stays the cell.
  */
 function withValueLabels(series, horizontal, textOf, labelable = () => true) {
-    const labeled = (entry) => entry.type === "bar" && entry.stack === undefined && Array.isArray(entry.data);
+    const labeled = (entry) => entry.type === "bar" && entry.stack === undefined && isUnknownArray(entry.data);
     let count = 0;
     for (const entry of series) {
-        if (labeled(entry))
+        if (labeled(entry) && isUnknownArray(entry.data))
             count += entry.data.length;
     }
     if (count === 0 || count > BAR_VALUE_LABEL_LIMIT) {
         return [...series];
     }
     return series.map((entry, index) => {
-        if (!labeled(entry) || !labelable(index))
+        if (!labeled(entry) || !labelable(index) || !isUnknownArray(entry.data))
             return entry;
         const data = entry.data.map((item) => {
             // A bar item is a pair or an object whose value is the pair, thus the two forms read one field.
-            const fields = typeof item === "object" && item !== null && !Array.isArray(item) ? item : { value: item };
-            if (fields.label !== undefined || !Array.isArray(fields.value))
+            const fields = parseUnknownRecord(item) ?? { value: item };
+            const itemValue = fields.value;
+            if (fields.label !== undefined || !isUnknownArray(itemValue))
                 return item;
-            const cell = fields.value[horizontal ? 0 : 1];
+            const read = itemValue[horizontal ? 0 : 1];
+            const cell = typeof read === "number" || typeof read === "string" ? read : undefined;
             return { ...fields, label: { show: true, position: labelPosition(cell, horizontal), formatter: textOf(cell, index) } };
         });
         return { ...entry, data };
@@ -3173,12 +3279,13 @@ function labelRoom(series, horizontal) {
     let negative = false;
     let positive = false;
     for (const entry of series) {
-        if (entry.type !== "bar" || !Array.isArray(entry.data))
+        if (entry.type !== "bar" || !isUnknownArray(entry.data))
             continue;
         for (const item of entry.data) {
-            if (typeof item !== "object" || item === null || Array.isArray(item) || item.label === undefined)
+            const fields = parseUnknownRecord(item);
+            if (fields?.label === undefined)
                 continue;
-            const value = item.value;
+            const value = fields.value;
             // The sign rule of `labelPosition`: a bar under zero puts its label at its lower end.
             if ((toNumber(Array.isArray(value) ? value[horizontal ? 0 : 1] : null) ?? 0) < 0)
                 negative = true;
@@ -3303,6 +3410,9 @@ function histogramEdges(values) {
     const sorted = [...values].sort((a, b) => a - b);
     const min = sorted[0];
     const max = sorted[sorted.length - 1];
+    if (min === undefined || max === undefined) {
+        return [];
+    }
     if (max === min) {
         return [min, max];
     }
@@ -3335,16 +3445,20 @@ function autoBinCount(sorted, min, max) {
 /** The bin counts for the values against the edges. The max value falls in the last bin. */
 function binCounts(values, edges) {
     const bins = edges.length - 1;
-    const counts = new Array(bins).fill(0);
     const min = edges[0];
-    const width = (edges[bins] - min) / bins;
+    const max = edges[bins];
+    if (bins < 1 || min === undefined || max === undefined) {
+        return [];
+    }
+    const width = (max - min) / bins;
+    const counts = new Array(bins).fill(0);
     for (const value of values) {
         let index = width === 0 ? 0 : Math.floor((value - min) / width);
         if (index < 0)
             index = 0;
         if (index >= bins)
             index = bins - 1;
-        counts[index] += 1;
+        counts[index] = (counts[index] ?? 0) + 1;
     }
     return counts;
 }
@@ -3352,8 +3466,12 @@ function binCounts(values, edges) {
 function histogramSeries(values, edges, name) {
     const counts = binCounts(values, edges);
     const data = [];
-    for (let i = 0; i < counts.length; i++) {
-        data.push([(edges[i] + edges[i + 1]) / 2, counts[i]]);
+    for (const [index, count] of counts.entries()) {
+        const low = edges[index];
+        const high = edges[index + 1];
+        if (low === undefined || high === undefined)
+            continue;
+        data.push([(low + high) / 2, count]);
     }
     if (name === undefined) {
         return { type: "bar", barWidth: "99%", data };
@@ -3439,6 +3557,8 @@ function violinShape(values) {
         return undefined;
     const min = sorted[0];
     const max = sorted[n - 1];
+    if (min === undefined || max === undefined)
+        return undefined;
     const grid = [];
     for (let point = 0; point < VIOLIN_GRID_POINTS; point += 1) {
         grid.push(min + (point * (max - min)) / (VIOLIN_GRID_POINTS - 1));
@@ -3469,13 +3589,10 @@ function roundWidth(width) {
  * linearly between the `floor` and the `ceil` of that index.
  */
 function quantileType7(sorted, p) {
-    const n = sorted.length;
-    if (n === 1)
-        return sorted[0];
-    const index = p * (n - 1);
-    const low = Math.floor(index);
-    const high = Math.ceil(index);
-    if (low === high)
-        return sorted[low];
-    return sorted[low] + (index - low) * (sorted[high] - sorted[low]);
+    const index = p * (sorted.length - 1);
+    const low = sorted[Math.floor(index)];
+    const high = sorted[Math.ceil(index)];
+    if (low === undefined || high === undefined)
+        return Number.NaN;
+    return low + (index - Math.floor(index)) * (high - low);
 }