ggaction 0.0.12 → 0.0.15

package/src/materialization/scales/policies/offset.js

@@ -1,4 +1,4 @@
-import { normalizeOffsetPadding } from "../../../grammar/bars/geometry.js";
+import { normalizeOffsetScalePolicy } from "../../../grammar/bars/geometry.js";
 
 function resolveParentSlot(consumer, resolvedScales, parentChannel) {
   if (parentChannel === "x" && consumer.layer.encoding?.x?.bin !== undefined) {
@@ -16,6 +16,7 @@ function resolveParentSlot(consumer, resolvedScales, parentChannel) {
 }
 
 export function resolveOffsetScalePolicy({
+  scale,
   consumers,
   resolvedScales,
   markConfigs,
@@ -34,21 +35,62 @@ export function resolveOffsetScalePolicy({
       `${channel} scale "${id}" requires one shared resolved ${parentChannel} categorical slot.`
     );
   }
-  const paddings = consumers.map(consumer => normalizeOffsetPadding(
+  return {
+    parentBandwidth: slots[0],
+    ...resolveRequestedOffsetPolicy({
+      scale,
+      consumers,
+      markConfigs,
+      id,
+      channel
+    })
+  };
+}
+
+/**
+ * Resolve the requested offset policy independently from its parent slot.
+ * Semantic scale fields are canonical. Consistent legacy mark-owned padding is
+ * retained as a fallback until the next successful scale/encoding edit migrates
+ * it into the semantic scale.
+ */
+export function resolveRequestedOffsetPolicy({
+  scale,
+  consumers = [],
+  markConfigs = {},
+  id = scale?.id ?? channel,
+  channel = "xOffset"
+}) {
+  const semanticPatch = scale === undefined
+    ? {}
+    : Object.fromEntries(
+        ["padding", "paddingInner", "paddingOuter", "align"]
+          .filter(property => Object.hasOwn(scale, property))
+          .map(property => [property, scale[property]])
+      );
+  if (
+    Object.hasOwn(semanticPatch, "padding") ||
+    ["paddingInner", "paddingOuter", "align"].every(
+      property => Object.hasOwn(semanticPatch, property)
+    )
+  ) {
+    return normalizeOffsetScalePolicy(semanticPatch, undefined, channel);
+  }
+  const legacyPolicies = consumers.map(consumer => normalizeOffsetScalePolicy(
     markConfigs[consumer.layer.id]?.[channel],
     undefined,
     channel
   ));
   const signatures = new Set(
-    paddings.map(padding => JSON.stringify(padding))
+    legacyPolicies.map(policy => JSON.stringify(policy))
   );
-  if (signatures.size !== 1) {
+  if (signatures.size > 1) {
     throw new Error(
       `${channel} scale "${id}" requires one shared padding policy.`
     );
   }
-  return {
-    parentBandwidth: slots[0],
-    ...paddings[0]
-  };
+  const legacy = legacyPolicies[0] ?? normalizeOffsetScalePolicy(
+    {}, undefined, channel
+  );
+  if (scale === undefined) return legacy;
+  return normalizeOffsetScalePolicy(semanticPatch, legacy, channel);
 }

package/src/materialization/scales/policies/series.js

@@ -1,3 +1,4 @@
+import { isSourceOwnedText } from "../../../grammar/text.js";
 import {
   isTransformedScaleType,
   resolveContinuousDomain,
@@ -21,7 +22,10 @@ export function resolveSeriesLayoutDomain({
     (_, index) => seriesLayouts[index] !== undefined
   );
   const directConsumers = valuesByConsumer.filter(
-    (_, index) => seriesLayouts[index] === undefined
+    ({ consumer, scalePolicy }, index) =>
+      scalePolicy !== false &&
+      seriesLayouts[index] === undefined &&
+      !isSourceOwnedText(consumer.layer)
   );
   const compatibleDirect = directConsumers.every(({ consumer }) =>
     layoutConsumers.every(({ consumer: layoutConsumer }) => {

package/src/materialization/scales/resolve.js

@@ -1,3 +1,4 @@
+import { validateContinuousColorConsumer } from "../../grammar/scales/colorConsumers.js";
 import {
   isContinuousColorScaleType,
   isDiscretePositionScaleType,
@@ -16,17 +17,19 @@ import {
   resolveScaleRange,
   resolveSequentialColorStops,
   resolveShapeRange,
+  resolveSizeScale,
   resolveSizeRange,
   resolveStrokeDashRange,
   resolveStrokeWidthRange,
   resolveTransformedDomain,
   SCALE_ROLES,
+  validateSequentialMidpoint,
   validateLinearScaleType,
   validateOrdinalScaleType,
   validateScaleTypeForRole,
   validateTimeScaleType
 } from "../../grammar/scales/index.js";
-import { resolveArcAutoPositionRange } from "./policies/arc.js";
+import { resolveArcAutoPositionRange, resolveMeasuredRadiusDomain, validateMeasuredRadiusConsumers } from "./policies/arc.js";
 import { resolveTemporalBarBand } from "./policies/bar.js";
 import { resolveOffsetScalePolicy } from "./policies/offset.js";
 import { resolveBinnedPositionDomain } from "./policies/binnedPosition.js";
@@ -94,7 +97,8 @@ function resolveRange({
   isSequentialColor,
   isDiscretizedColor,
   isOrdinalOffset,
-  discretizedScale
+  discretizedScale,
+  polarFrame
 }) {
   if (channel === "color") {
     if (isDiscretizedColor) return discretizedScale.range;
@@ -112,7 +116,7 @@ function resolveRange({
     scale,
     channel,
     domain,
-    range: resolveScaleRange(scale.range, channel, bounds),
+    range: resolveScaleRange(scale.range, channel, bounds, polarFrame),
     markConfigs
   });
 }
@@ -139,7 +143,9 @@ function resolveContinuousScale({
             : validateLinearScaleType(scale.type),
     domain,
     range,
+    ...(scale.midpoint === undefined ? {} : { midpoint: scale.midpoint }),
     ...(scale.clamp === undefined ? {} : { clamp: scale.clamp }),
+    ...(scale.radialMapping === undefined ? {} : { radialMapping: scale.radialMapping }),
     ...(scale.type === "log"
       ? {
           base: normalizeTransformParameters("log", {
@@ -182,19 +188,43 @@ function reverseResolvedScale(scale) {
   };
 }
 
-export function resolveScaleMaterialization({
-  id,
-  scale,
-  channel,
-  consumers,
-  valuesByConsumer,
-  bounds,
-  resolvedScales,
-  markConfigs
-}) {
+export function resolveScaleMaterialization(options) {
+  const {
+    id,
+    scale,
+    channel: requestedChannel,
+    consumers,
+    valuesByConsumer,
+    bounds,
+    resolvedScales,
+    markConfigs,
+    thetaScales,
+    polarFrame
+  } = options;
+  const channel = requestedChannel === "stroke" ? "color" : requestedChannel;
   const allValues = valuesByConsumer
     .flatMap(item => item.values)
     .filter(value => value !== undefined);
+  const preserved = resolvedScales[id]?.domain;
+  if (
+    scale.domain === "auto" &&
+    Array.isArray(preserved) &&
+    consumers.some(({ layer }) =>
+      markConfigs?.[layer.id]?.markFilter?.empty === true
+    )
+  ) {
+    return resolveScaleMaterialization({
+      ...options,
+      scale: { ...scale, domain: preserved },
+      valuesByConsumer: valuesByConsumer.map(item => ({
+        ...item,
+        categoryOrder: undefined
+      }))
+    });
+  }
+  if (channel === "size") {
+    return resolveSizeScale({ ...scale, values: allValues });
+  }
   const isSequentialColor = channel === "color" &&
     isContinuousColorScaleType(scale.type);
   const isDiscretizedColor = channel === "color" &&
@@ -210,6 +240,16 @@ export function resolveScaleMaterialization({
     !isOrdinalOffset &&
     isDiscretePositionScaleType(scale.type);
 
+  if (isSequentialColor || isDiscretizedColor) {
+    for (const consumer of consumers) {
+      validateContinuousColorConsumer(
+        consumer.layer,
+        consumer.encoding,
+        scale,
+        { channel: consumer.channel }
+      );
+    }
+  }
   let discretizedScale;
   if (isDiscretizedColor) {
     discretizedScale = resolveDiscretizedColorScale({
@@ -225,8 +265,7 @@ export function resolveScaleMaterialization({
         valuesByConsumer,
         channel,
         scale,
-        id,
-        allValues
+        id
       });
   const seriesLayouts = valuesByConsumer.map(item => item.seriesLayout);
   const seriesDomain = isDiscretizedColor || binnedDomain !== undefined
@@ -247,7 +286,7 @@ export function resolveScaleMaterialization({
   }
   const domain = isDiscretizedColor
     ? discretizedScale.domain
-    : categoryOrderDomain ?? binnedDomain ?? seriesDomain ?? resolveDefaultDomain({
+    : resolveMeasuredRadiusDomain({ scale, channel, allValues }) ?? categoryOrderDomain ?? binnedDomain ?? seriesDomain ?? resolveDefaultDomain({
         scale,
         allValues,
         isOrdinalAppearance,
@@ -265,8 +304,16 @@ export function resolveScaleMaterialization({
     isSequentialColor,
     isDiscretizedColor,
     isOrdinalOffset,
-    discretizedScale
+    discretizedScale,
+    polarFrame
   });
+  validateSequentialMidpoint(scale.midpoint, scale.type, domain);
+  if (scale.midpoint !== undefined && (channel !== "color" || consumers.some(
+    consumer => consumer.encoding.fieldType !== "quantitative"
+  ))) {
+    throw new Error("Scale midpoint requires quantitative color consumers.");
+  }
+  validateMeasuredRadiusConsumers({ scale, domain, range, consumers, markConfigs, thetaScales });
   if (channel === "shape" && domain.length > range.length) {
     throw new Error(
       `Shape scale "${id}" requires at least one distinct shape per domain value.`
@@ -281,6 +328,7 @@ export function resolveScaleMaterialization({
           values: allValues,
           range: scale.range,
           ...resolveOffsetScalePolicy({
+            scale,
             consumers,
             resolvedScales,
             markConfigs,

package/src/materialization/selection/compatibility.js

@@ -0,0 +1,11 @@
+export function assertEncodingSelectionCompatibility(program, target, channels) {
+  for (const [id, selection] of Object.entries(
+    program.materializationConfigs.selections ?? {}
+  )) {
+    if (selection.target === target && channels.includes(selection.selector?.channel)) {
+      throw new Error(
+        `Cannot remove ${selection.selector.channel} encoding while selection "${id}" references that channel.`
+      );
+    }
+  }
+}

package/src/materialization/selection/items/arc.js

@@ -1,7 +1,7 @@
 import { deriveArcSectors } from "../../../grammar/arcs.js";
 import { resolvePolarPoint } from "../../../grammar/polarPaths.js";
-import { resolvePolarFrame } from "../../../grammar/polar.js";
-import { resolveGraphicBounds } from "../../../layout/canvas.js";
+import { readScaleField } from "../../../grammar/scales/index.js";
+import { resolveCoordinatePolarFrame } from "../../coordinateBounds.js";
 import {
   concreteProperties,
   finalizeItems,
@@ -11,7 +11,7 @@ import {
 export function resolveArcItems(program, layer, dataset) {
   const thetaScale = program.resolvedScales[layer.encoding?.theta?.scale];
   const radiusScale = program.resolvedScales[layer.encoding?.radius?.scale];
-  const frame = resolvePolarFrame(resolveGraphicBounds(program));
+  const frame = resolveCoordinatePolarFrame(program, layer.coordinate);
   const derived = deriveArcSectors(dataset.values, layer, {
     thetaScale,
     ...(radiusScale === undefined ? {} : { radiusScale }),
@@ -19,14 +19,25 @@ export function resolveArcItems(program, layer, dataset) {
     innerRadiusRatio: program.markConfigs[layer.id]?.innerRadius ?? 0
   });
   const graphic = program.graphicSpec.objects[layer.id];
+  const stroke = layer.encoding?.stroke;
   const definitions = derived.sectors.map((sector, index) => {
     const members = sector.sourceIndices.map(index => dataset.values[index]);
+    const strokeValues = stroke === undefined ? undefined : readScaleField(
+      members,
+      stroke.field,
+      stroke.fieldType,
+      { temporalUnit: stroke.temporalUnit }
+    );
+    if (strokeValues !== undefined && new Set(strokeValues).size !== 1) {
+      throw new Error("Arc stroke requires one value within each sector.");
+    }
     return {
       fields: uniqueFields(members),
       channels: {
         theta: sector.theta,
         ...(sector.radius === undefined ? {} : { radius: sector.radius }),
-        ...(sector.color === undefined ? {} : { color: sector.color })
+        ...(sector.color === undefined ? {} : { color: sector.color }),
+        ...(strokeValues === undefined ? {} : { stroke: strokeValues[0] })
       },
       properties: {
         ...concreteProperties(graphic.items[index]?.properties),
@@ -36,6 +47,19 @@ export function resolveArcItems(program, layer, dataset) {
           (sector.innerRadius + sector.outerRadius) / 2
         )
       },
+      geometry: {
+        kind: "arc",
+        centerX: frame.centerX,
+        centerY: frame.centerY,
+        startTheta: sector.startTheta +
+          Math.sign(sector.endTheta - sector.startTheta) *
+          (program.markConfigs[layer.id]?.padAngle ?? 0) / 2,
+        endTheta: sector.endTheta -
+          Math.sign(sector.endTheta - sector.startTheta) *
+          (program.markConfigs[layer.id]?.padAngle ?? 0) / 2,
+        innerRadius: sector.innerRadius,
+        outerRadius: sector.outerRadius
+      },
       members
     };
   });

package/src/materialization/selection/items/bar.js

@@ -1,4 +1,5 @@
-import { deriveBarAggregates } from "../../../grammar/bars/aggregate.js";
+import { deriveSeriesBarCells } from "../../../grammar/bars/aggregate.js";
+import { readSeriesIdentity } from "../../../grammar/pathSeries.js";
 import {
   BAR_GRAINS,
   resolveBarChannels,
@@ -7,9 +8,9 @@ import {
   resolveBarGrain
 } from "../../../grammar/bars/policy.js";
 import { numericExtent } from "../../../grammar/numeric.js";
-import { layoutSeriesPartition } from "../../../grammar/seriesLayout.js";
 import {
   readNominalField,
+  readScaleField,
   readTemporalField
 } from "../../../grammar/scales/index.js";
 import { findSemanticScale } from "../../../selectors/scales.js";
@@ -24,7 +25,7 @@ import {
 
 function categoryValues(rows, encoding) {
   return encoding.fieldType === "temporal"
-    ? readTemporalField(rows, encoding.field)
+    ? readTemporalField(rows, encoding.field, encoding.temporalUnit)
     : readNominalField(rows, encoding.field);
 }
 
@@ -36,28 +37,35 @@ function aggregateMembers(rows, layer, cell, channels) {
   const colors = !["nominal", "ordinal"].includes(color?.fieldType)
     ? undefined
     : readNominalField(rows, color.field);
+  const identity = layer.encoding?.group === undefined ? undefined : readSeriesIdentity(rows, layer);
   return rows.filter((_, index) =>
     categories[index] === categoryValue &&
-    (colors === undefined || colors[index] === cell.color)
+    (identity === undefined ? colors === undefined || colors[index] === cell.color : identity.values[index] === cell.series)
   );
 }
 
 function aggregateCellDefinitions(program, layer, dataset) {
   const channels = resolveBarChannels(layer);
-  const derived = deriveBarAggregates(dataset.values, layer).values;
   const categoryEncoding = layer.encoding[channels.category];
   const categoryScale = program.resolvedScales[categoryEncoding.scale];
-  const measureScale = program.resolvedScales[
-    layer.encoding[channels.measure].scale
-  ];
   const colorEncoding = layer.encoding?.color;
   const colorScale = program.resolvedScales[colorEncoding?.scale];
   const offsetChannel = resolveBarOffsetChannel(layer);
   const offsetScale = program.resolvedScales[layer.encoding?.[offsetChannel]?.scale];
   const layout = resolveBarColorLayout(layer);
+  const stroke = layer.encoding?.stroke;
 
   function definition(cell, start, end) {
     const members = aggregateMembers(dataset.values, layer, cell, channels);
+    const strokeValues = stroke === undefined ? undefined : readScaleField(
+      members,
+      stroke.field,
+      stroke.fieldType,
+      { temporalUnit: stroke.temporalUnit }
+    );
+    if (strokeValues !== undefined && new Set(strokeValues).size !== 1) {
+      throw new Error("Bar stroke requires one value within each aggregate cell.");
+    }
     return {
       fields: uniqueFields(members),
       channels: {
@@ -65,72 +73,20 @@ function aggregateCellDefinitions(program, layer, dataset) {
         [channels.measure]: start,
         [`${channels.measure}2`]: end,
         ...(cell.color === undefined ? {} : { color: cell.color }),
+        ...(strokeValues === undefined ? {} : { stroke: strokeValues[0] }),
         ...(layer.encoding?.[offsetChannel] === undefined
           ? {}
-          : { [offsetChannel]: cell.color })
+          : { [offsetChannel]: cell.series ?? cell.color })
       },
       members
     };
   }
 
-  if (colorEncoding?.fieldType === "quantitative") {
-    const cells = new Map(derived.map(cell => [
-      cell[channels.category],
-      cell
-    ]));
-    const categories = ["ordinal", "band", "point"].includes(categoryScale.type)
-      ? categoryScale.domain
-      : [...new Set(derived.map(cell => cell[channels.category]))]
-          .sort((left, right) => left - right);
-    return categories.flatMap(category => {
-      const cell = cells.get(category);
-      return cell === undefined
-        ? []
-        : [definition(cell, measureScale.domain[0], cell[channels.measure])];
-    });
-  }
-
-  if (layout === "group" && offsetScale !== undefined) {
-    const categoryIndex = new Map(
-      categoryScale.domain.map((value, index) => [value, index])
-    );
-    const offsetIndex = new Map(
-      offsetScale.domain.map((value, index) => [value, index])
-    );
-    const cells = [...derived].sort((left, right) =>
-      categoryIndex.get(left[channels.category]) -
-        categoryIndex.get(right[channels.category]) ||
-      offsetIndex.get(left.color) - offsetIndex.get(right.color)
-    );
-    return cells.map(cell => definition(
-      cell,
-      measureScale.domain[0],
-      cell[channels.measure]
-    ));
-  }
-
-  const categories = ["ordinal", "band", "point"].includes(categoryScale.type)
-    ? categoryScale.domain
-    : [...new Set(derived.map(cell => cell[channels.category]))]
-        .sort((left, right) => left - right);
-  const series = colorScale?.domain ?? [undefined];
-  const lookup = new Map(derived.map(cell => [
-    JSON.stringify([cell[channels.category], cell.color]),
-    cell
-  ]));
-  const baseline = layout === "overlay" ? measureScale.domain[0] : 0;
-  return categories.flatMap(category => {
-    const cells = series.map(color =>
-      lookup.get(JSON.stringify([category, color]))
-    );
-    const values = cells.map(cell => cell?.[channels.measure] ?? 0);
-    return layoutSeriesPartition(values, layout, { baseline }).flatMap(segment => {
-      const cell = cells[segment.index];
-      return cell === undefined
-        ? []
-        : [definition(cell, segment.start, segment.end)];
-    });
-  });
+  const categories = categoryScale.type === "time" ? undefined : categoryScale.domain;
+  const series = layout === "group" ? offsetScale?.domain
+    : layer.encoding.group === undefined && colorEncoding?.fieldType !== "quantitative" ? colorScale?.domain : undefined;
+  return deriveSeriesBarCells(dataset.values, layer, categories, series)
+    .map(({ cell, start, end }) => definition(cell, start, end));
 }
 
 function histogramDefinitions(program, layer, dataset) {
@@ -144,8 +100,18 @@ function histogramDefinitions(program, layer, dataset) {
     resolvedScales: program.resolvedScales
   });
   const colorScale = program.resolvedScales[colorEncoding?.scale];
+  const stroke = layer.encoding?.stroke;
   return segments.map(segment => {
-    const colorValue = colorScale?.domain[segment.category];
+    const colorValue = segment.colorValue ?? colorScale?.domain[segment.category];
+    const strokeValues = stroke === undefined ? undefined : readScaleField(
+      segment.members,
+      stroke.field,
+      stroke.fieldType,
+      { temporalUnit: stroke.temporalUnit }
+    );
+    if (strokeValues !== undefined && new Set(strokeValues).size !== 1) {
+      throw new Error("Histogram stroke requires one value within each bin/series cell.");
+    }
     return {
       fields: uniqueFields(segment.members),
       channels: {
@@ -153,7 +119,8 @@ function histogramDefinitions(program, layer, dataset) {
         x2: segment.end,
         y: segment.stackStart,
         y2: segment.stackEnd,
-        ...(colorValue === undefined ? {} : { color: colorValue })
+        ...(colorValue === undefined ? {} : { color: colorValue }),
+        ...(strokeValues === undefined ? {} : { stroke: strokeValues[0] })
       },
       members: segment.members
     };
@@ -244,14 +211,18 @@ export function resolveBarItems(program, layer, dataset, selectionGrain) {
   if (definitions === undefined) {
     throw new Error(`Bar mark "${layer.id}" is incomplete for selection.`);
   }
+  const graphicTypes = Object.hasOwn(
+    program.markConfigs[layer.id]?.barAppearance ?? {},
+    "cornerRadius"
+  ) ? ["rect", "path"] : "rect";
   if (selectionGrain === "stack") {
     return finalizeItems(
       program,
       layer,
       "stack",
       barStackDefinitions(layer, grain, definitions),
-      "rect"
+      graphicTypes
     );
   }
-  return finalizeItems(program, layer, grain, definitions, "rect");
+  return finalizeItems(program, layer, grain, definitions, graphicTypes);
 }

package/src/materialization/selection/items/common.js

@@ -1,3 +1,4 @@
+import { normalizeTemporalValue } from "../../../grammar/scales/fields.js";
 import { cloneAndFreeze, isPlainObject } from "../../../core/immutable.js";
 import {
   MARK_GRAPHIC_PROPERTIES,
@@ -5,6 +6,7 @@ import {
 } from "../../../grammar/markSelection.js";
 import { unionConcreteGraphicBounds } from
   "../../../grammar/schemas/graphicBounds.js";
+import { readRectItemGeometry } from "../../../grammar/roundedRect.js";
 
 export function itemKey(layer, grain, index) {
   return `${layer.id}/${grain}/${index}`;
@@ -16,8 +18,13 @@ function graphicId(layer, index) {
 
 function encodingValue(row, encoding) {
   if (encoding === undefined) return undefined;
-  if (Object.hasOwn(encoding, "field")) return row?.[encoding.field];
-  return encoding.datum;
+  const value = Object.hasOwn(encoding, "field") ? row?.[encoding.field] : encoding.datum;
+  if (encoding.fieldType !== "temporal") return value;
+  try {
+    return normalizeTemporalValue(value, encoding.field, 0, encoding.temporalUnit);
+  } catch {
+    return undefined;
+  }
 }
 
 export function channelMapFromRow(row, layer) {
@@ -48,14 +55,15 @@ export function uniqueFields(rows) {
 
 function requireResolvedGraphic(program, layer, type) {
   const graphic = program.graphicSpec.objects[layer.id];
+  const types = Array.isArray(type) ? type : [type];
   const compatibleCollection = graphic?.type === "collection" &&
-    graphic.items?.every(child => child.type === type);
+    graphic.items?.every(child => types.includes(child.type));
   if (
-    (graphic?.type !== type && !compatibleCollection) ||
+    (!types.includes(graphic?.type) && !compatibleCollection) ||
     !Array.isArray(graphic.items)
   ) {
     throw new Error(
-      `Mark "${layer.id}" requires a materialized ${type} collection for selection.`
+      `Mark "${layer.id}" requires a materialized ${types.join("/")} collection for selection.`
     );
   }
   return graphic;
@@ -72,6 +80,13 @@ export function concreteProperties(properties) {
   );
 }
 
+function selectableGraphicProperties(item) {
+  return {
+    ...concreteProperties(item?.properties),
+    ...(readRectItemGeometry(item) ?? {})
+  };
+}
+
 function sharedConcreteProperties(items) {
   if (items.length === 0) return {};
   const shared = concreteProperties(items[0].properties);
@@ -112,7 +127,10 @@ export function finalizeItems(program, layer, grain, definitions, graphicType) {
     const items = indices.map(childIndex => graphic.items[childIndex]);
     const properties = definition.properties ?? (
       items.length === 1
-        ? concreteProperties(items[0].properties)
+        ? selectableGraphicProperties({
+            type: items[0].type ?? graphic.type,
+            properties: items[0].properties
+          })
         : {
             ...sharedConcreteProperties(items),
             ...collectionBounds(program, items)
@@ -125,6 +143,9 @@ export function finalizeItems(program, layer, grain, definitions, graphicType) {
       fields: cloneAndFreeze(definition.fields),
       channels: cloneAndFreeze(definition.channels),
       properties: cloneAndFreeze(properties),
+      ...(definition.geometry === undefined
+        ? {}
+        : { geometry: cloneAndFreeze(definition.geometry) }),
       members: Object.freeze([...definition.members]),
       graphicIds: Object.freeze(items.map((child, childOffset) =>
         child.id ?? graphicId(layer, indices[childOffset])

package/src/materialization/selection/items/path.js

@@ -25,20 +25,10 @@ function rowsForSeries(rows, key) {
 
 function seriesDefinitions(layer, rows, series) {
   return series.map(item => {
-    const members = rowsForSeries(rows, item.key);
+    const members = item.sourceIndices === undefined ? rowsForSeries(rows, item.key)
+      : item.sourceIndices.map(index => rows[index]);
     const fields = { ...uniqueFields(members), ...item.key };
-    const channels = Object.fromEntries(
-      Object.entries(layer.encoding ?? {}).flatMap(([channel, encoding]) => {
-        if (encoding.field === undefined) {
-          return Object.hasOwn(encoding, "datum")
-            ? [[channel, encoding.datum]]
-            : [];
-        }
-        return Object.hasOwn(fields, encoding.field)
-          ? [[channel, fields[encoding.field]]]
-          : [];
-      })
-    );
+    const channels = channelMapFromRow(fields, layer);
     return { fields, channels, members };
   });
 }