ggaction 0.0.12 → 0.0.13

package/src/materialization/marks/index.js

@@ -1,8 +1,11 @@
+import { isSourceOwnedText } from "../../grammar/text.js";
+import { findLayer } from "../../selectors/layers.js";
 import {
   POSITION_CHANNELS,
   POSITION_ENCODING_CHANNELS
 } from "../../core/vocabulary.js";
 import { getMarkMaterializationPolicy } from "./policies.js";
+import { buildMaterializationPlan } from "../planner.js";
 
 export {
   canMaterializeArc,
@@ -13,10 +16,29 @@ export {
   canMaterializeRect,
   canMaterializeRule,
   canMaterializeText,
-  canMaterializeTick
+  canMaterializeTick,
+  isTextSource
 } from "./capabilities.js";
 
-export function getMarkRematerializationStep(layer) {
+export function getLayerScaleIds(layer) {
+  if (isSourceOwnedText(layer)) return [];
+  return [
+    ...Object.values(layer.encoding ?? {}).map(encoding => encoding?.scale),
+    ...(layer.encoding?.parallel?.dimensions ?? []).map(dimension => dimension.scale)
+  ].filter(scale => scale !== undefined);
+}
+
+export function getScaleConsumerMarkSteps(program, scaleIds) {
+  return program.semanticSpec.layers
+    .filter(layer => getLayerScaleIds(layer).some(id => scaleIds.includes(id)))
+    .map(layer => getMarkMaterializationStep(program, layer))
+    .filter(step => step !== undefined);
+}
+
+export function getMarkRematerializationStep(program, layer) {
+  if (program.markConfigs?.[layer.id]?.markFilter?.empty === true) {
+    return { op: "materializeEmptyMark", args: { id: layer.id } };
+  }
   const policy = getMarkMaterializationPolicy(layer);
   return policy === undefined
     ? undefined
@@ -28,14 +50,15 @@ export function getMarkMaterializationStep(program, layer) {
   if (policy === undefined || !policy.canMaterialize(program, layer)) {
     return undefined;
   }
-  return getMarkRematerializationStep(layer);
+  return getMarkRematerializationStep(program, layer);
 }
 
 export function getSourceDependentMarkSteps(program, sourceId) {
-  return program.semanticSpec.layers.flatMap(layer =>
+  return (program.semanticSpec.layers ?? []).flatMap(layer =>
     layer.source === sourceId &&
     getMarkMaterializationPolicy(layer)?.sourceDependent === true
-      ? [getMarkMaterializationStep(program, layer)].filter(
+      ? [getMarkMaterializationStep(program, layer) ??
+          getExistingMarkRematerializationStep(program, layer)].filter(
           step => step !== undefined
         )
       : []
@@ -46,39 +69,39 @@ export function getPositionEncodingMaterializationSteps(program, layer, scaleId)
   const policy = getMarkMaterializationPolicy(layer);
   if (policy === undefined) return [];
   const complete = policy.canMaterialize(program, layer);
-  const mark = getMarkRematerializationStep(layer);
+  const mark = getMarkRematerializationStep(program, layer);
   const sharedConsumerMarks = (program.semanticSpec.layers ?? [])
     .filter(candidate =>
       candidate.id !== layer.id &&
+      !isSourceOwnedText(candidate) &&
       POSITION_CHANNELS.some(channel =>
         candidate.encoding?.[channel]?.scale === scaleId
       )
     )
     .map(candidate => getMarkMaterializationStep(program, candidate))
     .filter(step => step !== undefined);
+  const dependentMarks = [mark, ...sharedConsumerMarks]
+    .flatMap(step => getSourceDependentMarkSteps(program, step.args.id));
   const scale = {
     op: "rematerializeScale",
     args: sharedConsumerMarks.length === 0
       ? { id: scaleId }
       : { id: scaleId, marks: false }
   };
-  if (!complete) {
-    if (policy.positionEncoding.incomplete === "scale") {
-      return [scale, ...sharedConsumerMarks];
-    }
-    return policy.positionEncoding.scaleFirst
+  const direct = !complete && policy.positionEncoding.incomplete === "scale"
+    ? [scale, ...sharedConsumerMarks]
+    : policy.positionEncoding.scaleFirst
       ? [scale, mark, ...sharedConsumerMarks]
       : [mark, ...sharedConsumerMarks];
-  }
-  return policy.positionEncoding.scaleFirst
-    ? [scale, mark, ...sharedConsumerMarks]
-    : [mark, ...sharedConsumerMarks];
+  return buildMaterializationPlan({ marks: [...direct, ...dependentMarks] });
 }
 
 export function getScaleConsumerMaterializationMode(layer, channel) {
   const policy = getMarkMaterializationPolicy(layer);
   if (policy === undefined) return "direct";
   if (POSITION_ENCODING_CHANNELS.includes(channel)) {
+    // Attached labels require their source's completed geometry, after scales.
+    if (layer.source !== undefined && policy.sourceDependent === true) return "defer";
     return policy.scaleApplication.position ?? policy.scaleApplication.default;
   }
   if (policy.scaleApplication.deferredChannels?.includes(channel)) {
@@ -99,7 +122,7 @@ export function getExistingMarkRematerializationStep(program, layer) {
   ) {
     return undefined;
   }
-  return getMarkRematerializationStep(layer);
+  return getMarkRematerializationStep(program, layer);
 }
 
 export function getEncodingMaterializationStages(program, layer, channel, scale) {
@@ -111,22 +134,34 @@ export function getEncodingMaterializationStages(program, layer, channel, scale)
         args: { id: scale, guides: false, marks: false }
       }]
     : [];
-  const shared = policy.encoding?.sharedChannels?.includes(channel) === true &&
-    scale !== undefined;
+  const shared = scale !== undefined && (
+    scales.length > 0 || policy.encoding?.sharedChannels?.includes(channel) === true
+  );
   const candidates = shared
     ? program.semanticSpec.layers.filter(candidate =>
-        candidate.mark?.type === layer.mark?.type &&
-        candidate.encoding?.[channel]?.scale === scale
+        candidate.id === layer.id || candidate.encoding?.[channel]?.scale === scale
       )
     : [layer];
   const marks = candidates.flatMap(candidate => {
-    if (policy.encoding?.skipRematerialization?.(program, candidate) === true) {
+    const candidatePolicy = getMarkMaterializationPolicy(candidate);
+    if (candidatePolicy?.encoding?.skipRematerialization?.(program, candidate) === true) {
       return [];
     }
-    const step = policy.encoding?.completeOnly === true
+    const step = candidate.id !== layer.id || candidatePolicy?.encoding?.completeOnly === true
       ? getMarkMaterializationStep(program, candidate)
-      : getMarkRematerializationStep(candidate);
+      : getMarkRematerializationStep(program, candidate);
     return step === undefined ? [] : [step];
   });
   return { scales, marks };
 }
+
+// Reuse a plan's scale stage only when it covers every scale consumed by the mark.
+export function reusePlannedMarkScales(program, steps, scaleIds) {
+  const resolved = new Set(scaleIds);
+  return steps.map(step => {
+    const layer = findLayer(program, step.args?.id);
+    if (layer === undefined || getMarkMaterializationPolicy(layer)?.acceptsResolvedScales !== true ||
+        !getLayerScaleIds(layer).every(id => resolved.has(id))) return step;
+    return { ...step, args: { ...step.args, scales: false } };
+  });
+}

package/src/materialization/marks/policies.js

@@ -40,7 +40,9 @@ const MARK_MATERIALIZATION_POLICIES = Object.freeze({
   line: Object.freeze({
     canMaterialize: canMaterializeLine,
     op: "rematerializeLineMark",
+    acceptsResolvedScales: true,
     positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: false }),
+    encoding: Object.freeze({ scaleFirst: true, completeOnly: true }),
     scaleApplication: Object.freeze({ default: "defer" })
   }),
   area: Object.freeze({

package/src/materialization/rect.js

@@ -2,28 +2,36 @@ import {
   mapOrdinalPositionValues,
   readScaleField
 } from "../grammar/scales/index.js";
-import { RECT_MODES, resolveRectMode } from "../grammar/rects.js";
+import { normalizePositionDatum } from "../grammar/positionDatum.js";
+import { resolveGraphicBounds } from "../layout/canvas.js";
+import { RECT_MODES, resolveRectMode, rectUsesFields } from "../grammar/rects.js";
 import { DEFAULT_RECT_MARK } from "./rectConfig.js";
 import { mapScaleConsumerValues } from "./scales/map.js";
 
-function optionalValues(rows, encoding) {
+function optionalValues(rows, encoding, length, channel) {
+  if (Object.hasOwn(encoding, "datum")) {
+    const value = normalizePositionDatum(encoding.datum, encoding.fieldType, channel, encoding.temporalUnit, "Rect");
+    return Array.from({ length }, () => value);
+  }
   return readScaleField(rows, encoding.field, encoding.fieldType, {
-    allowUnknown: true
+    allowUnknown: true, temporalUnit: encoding.temporalUnit
   });
 }
 
 function requiredChannels(layer, mode) {
-  return mode === RECT_MODES.ranged
-    ? ["x", "x2", "y", "y2", ...(layer.encoding?.color ? ["color"] : [])]
-    : ["x", "y", ...(layer.encoding?.color ? ["color"] : [])];
+  const position = mode === RECT_MODES.xSpan ? ["x", "x2"]
+    : mode === RECT_MODES.ySpan ? ["y", "y2"]
+    : mode === RECT_MODES.ranged ? ["x", "x2", "y", "y2"] : ["x", "y"];
+  return [...position, ...(layer.encoding?.color ? ["color"] : [])];
 }
 
 export function resolveRectConsumerValues(layer, dataset, channel) {
-  const requested = optionalValues(dataset.values, layer.encoding[channel]);
+  const length = rectUsesFields(layer) ? dataset.values.length : 1;
+  const requested = optionalValues(dataset.values, layer.encoding[channel], length, channel);
   const mode = resolveRectMode(layer);
   if (mode === undefined) return requested;
   const complete = requiredChannels(layer, mode).map(candidate =>
-    optionalValues(dataset.values, layer.encoding[candidate])
+    optionalValues(dataset.values, layer.encoding[candidate], length, candidate)
   );
   return requested.map((value, index) =>
     complete.every(values => values[index] !== undefined) ? value : undefined
@@ -68,24 +76,22 @@ function appearance(config, fill) {
 export function resolveRectRows(program, layer, dataset) {
   const mode = resolveRectMode(layer);
   if (mode === undefined) return [];
-  const x = mappedEncoding(program, layer, dataset, "x");
-  const y = mappedEncoding(program, layer, dataset, "y");
-  const x2 = mode === RECT_MODES.ranged
-    ? mappedEncoding(program, layer, dataset, "x2")
-    : undefined;
-  const y2 = mode === RECT_MODES.ranged
-    ? mappedEncoding(program, layer, dataset, "y2")
-    : undefined;
+  const bounds = resolveGraphicBounds(program);
+  const x = layer.encoding.x === undefined ? undefined : mappedEncoding(program, layer, dataset, "x");
+  const y = layer.encoding.y === undefined ? undefined : mappedEncoding(program, layer, dataset, "y");
+  const x2 = layer.encoding.x2 === undefined ? undefined : mappedEncoding(program, layer, dataset, "x2");
+  const y2 = layer.encoding.y2 === undefined ? undefined : mappedEncoding(program, layer, dataset, "y2");
   const color = layer.encoding?.color === undefined
     ? undefined
     : mappedEncoding(program, layer, dataset, "color").values;
   const config = program.markConfigs[layer.id] ?? DEFAULT_RECT_MARK;
 
-  return dataset.values.flatMap((row, index) => {
+  const rows = rectUsesFields(layer) ? dataset.values : [{}];
+  return rows.flatMap((row, index) => {
     const fill = color === undefined ? config.fill : color[index];
     if (
-      !Number.isFinite(x.values[index]) ||
-      !Number.isFinite(y.values[index]) ||
+      (x !== undefined && !Number.isFinite(x.values[index])) ||
+      (y !== undefined && !Number.isFinite(y.values[index])) ||
       typeof fill !== "string"
     ) return [];
 
@@ -103,28 +109,22 @@ export function resolveRectRows(program, layer, dataset) {
         height
       };
     } else {
-      const endX = x2.values[index];
-      const endY = y2.values[index];
+      const startX = x?.values[index] ?? bounds.x;
+      const startY = y?.values[index] ?? bounds.y;
+      const endX = x2?.values[index] ?? bounds.x + bounds.width;
+      const endY = y2?.values[index] ?? bounds.y + bounds.height;
       if (!Number.isFinite(endX) || !Number.isFinite(endY)) return [];
       geometry = {
-        x: Math.min(x.values[index], endX),
-        y: Math.min(y.values[index], endY),
-        width: Math.abs(endX - x.values[index]),
-        height: Math.abs(endY - y.values[index])
+        x: Math.min(startX, endX),
+        y: Math.min(startY, endY),
+        width: Math.abs(endX - startX),
+        height: Math.abs(endY - startY)
       };
       if (geometry.width <= 0 || geometry.height <= 0) return [];
     }
     return [{
       row,
       sourceIndex: index,
-      channels: Object.fromEntries(
-        ["x", "y", "x2", "y2", "color"].flatMap(channel => {
-          const encoding = layer.encoding?.[channel];
-          return encoding?.field === undefined
-            ? []
-            : [[channel, row[encoding.field]]];
-        })
-      ),
       properties: { ...geometry, ...appearance(config, fill) }
     }];
   });

package/src/materialization/rowEncoding.js

@@ -5,15 +5,13 @@ import {
 import {
   mapOrdinalOffsetValues,
   mapOrdinalPositionValues,
-  readNominalField,
-  readQuantitativeField,
-  readScaleField,
-  readTemporalField
+  readScaleField
 } from "../grammar/scales/index.js";
 import {
   finiteMidpoint,
   requireFiniteResult
 } from "../grammar/numeric.js";
+import { normalizePositionDatum } from "../grammar/positionDatum.js";
 import { mapScaleConsumerValues } from "./scales/map.js";
 
 export function resolveRowEncodingValues(program, layer, dataset, channel) {
@@ -26,15 +24,17 @@ export function resolveRowEncodingValues(program, layer, dataset, channel) {
     );
   }
   const categorical = ["nominal", "ordinal"].includes(encoding.fieldType);
-  const values = Object.hasOwn(scale, "unknown")
-    ? readScaleField(dataset.values, encoding.field, encoding.fieldType, {
-        allowUnknown: true
-      })
-    : categorical
-      ? readNominalField(dataset.values, encoding.field)
-      : encoding.fieldType === "temporal"
-        ? readTemporalField(dataset.values, encoding.field)
-        : readQuantitativeField(dataset.values, encoding.field);
+  const values = Object.hasOwn(encoding, "datum")
+    ? Array(dataset.values.length).fill(normalizePositionDatum(
+        encoding.datum,
+        encoding.fieldType,
+        channel,
+        encoding.temporalUnit,
+        layer.mark.type[0].toUpperCase() + layer.mark.type.slice(1)
+      ))
+    : readScaleField(dataset.values, encoding.field, encoding.fieldType, {
+        allowUnknown: Object.hasOwn(scale, "unknown"), temporalUnit: encoding.temporalUnit
+      });
   if (categorical && OFFSET_POSITION_CHANNELS.includes(channel)) {
     return mapOrdinalOffsetValues(values, scale);
   }

package/src/materialization/scaleGuideDependencies.js

@@ -1,3 +1,4 @@
+import { isSourceOwnedText } from "../grammar/text.js";
 import { POSITION_ENCODING_CHANNELS } from "../core/vocabulary.js";
 import { materializedLegendUsesScale } from "./legends.js";
 import { buildMaterializationPlan } from "./planner.js";
@@ -19,10 +20,12 @@ const GRIDS = Object.freeze([
 
 function usesPositionalScale(program, id) {
   return program.semanticSpec.layers.some(layer =>
-    POSITION_ENCODING_CHANNELS.some(
-      channel => layer.encoding?.[channel]?.scale === id
-    ) || (layer.encoding?.parallel?.dimensions ?? []).some(
-      dimension => dimension.scale === id
+    !isSourceOwnedText(layer) && (
+      POSITION_ENCODING_CHANNELS.some(
+        channel => layer.encoding?.[channel]?.scale === id
+      ) || (layer.encoding?.parallel?.dimensions ?? []).some(
+        dimension => dimension.scale === id
+      )
     )
   );
 }
@@ -50,7 +53,7 @@ export function needsCanvasScaleRematerialization(program, scale) {
     (scale.range === "auto" ||
       usesRadialScale(program, scale.id) ||
       semanticGuideUsesScale(program, scale.id)) &&
-    program.resolvedScales[scale.id] !== undefined &&
+    (program.resolvedScales[scale.id] !== undefined || scale.radialMapping !== undefined) &&
     usesPositionalScale(program, scale.id)
   );
 }

package/src/materialization/scales/map.js

@@ -19,6 +19,7 @@ export function mapScaleConsumerValues(values, resolvedScale, channel) {
       resolvedScale.range,
       {
         interpolation: resolvedScale.interpolate,
+        midpoint: resolvedScale.midpoint,
         clamp: resolvedScale.clamp ?? false,
         ...(Object.hasOwn(resolvedScale, "unknown")
           ? { unknown: resolvedScale.unknown }

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

@@ -1,3 +1,4 @@
+import { validateMeasuredRadiusScale } from "../../../grammar/scales/radial.js";
 export function resolveArcAutoPositionRange({
   consumers,
   scale,
@@ -35,3 +36,44 @@ export function resolveArcAutoPositionRange({
   }
   return range;
 }
+
+
+export function resolveMeasuredRadiusDomain({ scale, channel, allValues }) {
+  if (scale.radialMapping === undefined) return undefined;
+  if (channel !== "radius") throw new Error("Measured radius scales support only radius consumers.");
+  const maximum = allValues.reduce((maximum, value) => Math.max(maximum, value), -Infinity);
+  if (!Number.isFinite(maximum) || maximum <= 0 || allValues.some(value => value < 0)) {
+    throw new Error("Measured radius requires finite non-negative aggregates and a positive maximum.");
+  }
+  const domain = scale.domain === "auto" ? [0, maximum] : scale.domain;
+  if (Array.isArray(domain) && domain[1] < maximum) {
+    throw new RangeError("Measured radius domain maximum must cover every category aggregate.");
+  }
+  return domain;
+}
+
+export function validateMeasuredRadiusConsumers({ scale, domain, range, consumers, markConfigs, thetaScales }) {
+  if (scale.radialMapping === undefined) return;
+  validateMeasuredRadiusScale({ ...scale, domain, range }, { allowAuto: true });
+  for (const consumer of consumers) {
+    const { layer, encoding } = consumer;
+    const theta = layer.encoding?.theta;
+    const thetaScale = thetaScales[layer.id];
+    if (!isPendingMeasuredRadiusConsumer(consumer) && (layer.mark?.type !== "arc" || !["count", "sum"].includes(encoding.aggregate) ||
+      !["nominal", "ordinal"].includes(theta?.fieldType) || theta.aggregate !== undefined ||
+      thetaScale?.type !== "band" || (thetaScale.paddingInner ?? 0) !== 0 || (thetaScale.paddingOuter ?? 0) !== 0)) {
+      throw new Error("Measured radius requires only equal-angle categorical Arc consumers.");
+    }
+    const config = markConfigs[layer.id] ?? {};
+    if ((config.padAngle ?? 0) !== 0) throw new Error("Measured Arc requires padAngle 0.");
+    if (scale.range !== "auto" && config.innerRadiusExplicit === true &&
+      Math.abs(config.innerRadius - range[0] / range[1]) > Number.EPSILON * 8) {
+      throw new Error("Measured Arc innerRadius must agree with its explicit radius range.");
+    }
+  }
+}
+
+export function isPendingMeasuredRadiusConsumer({ layer, channel, encoding }) {
+  return layer.mark?.type === "arc" && channel === "radius" &&
+    ["count", "sum"].includes(encoding.aggregate) && layer.encoding?.theta === undefined;
+}

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

@@ -1,11 +1,11 @@
+import { isSourceOwnedText } from "../../../grammar/text.js";
 import { resolveHistogramBins } from "../../../grammar/histogram.js";
 
 export function resolveBinnedPositionDomain({
   valuesByConsumer,
   channel,
   scale,
-  id,
-  allValues
+  id
 }) {
   const binnedPositions = valuesByConsumer.filter(
     ({ consumer }) =>
@@ -13,7 +13,10 @@ export function resolveBinnedPositionDomain({
       consumer.encoding.bin !== undefined
   );
   if (binnedPositions.length === 0) return undefined;
-  if (channel !== "x" || binnedPositions.length !== valuesByConsumer.length) {
+  const independentConsumers = valuesByConsumer.filter(({ consumer }) =>
+    !isSourceOwnedText(consumer.layer)
+  );
+  if (channel !== "x" || binnedPositions.length !== independentConsumers.length) {
     throw new Error(
       `Binned scale "${id}" cannot be shared with an unbinned consumer.`
     );
@@ -25,7 +28,7 @@ export function resolveBinnedPositionDomain({
     throw new Error(`Binned scale "${id}" requires one shared bin definition.`);
   }
   return resolveHistogramBins({
-    values: allValues,
+    values: binnedPositions.flatMap(item => item.values).filter(value => value !== undefined),
     bin: binnedPositions[0].consumer.encoding.bin,
     domain: scale.domain,
     nice: scale.nice ?? true,

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

@@ -1,3 +1,4 @@
+import { isSourceOwnedText } from "../../../grammar/text.js";
 import {
   isTransformedScaleType,
   resolveContinuousDomain,
@@ -21,7 +22,7 @@ export function resolveSeriesLayoutDomain({
     (_, index) => seriesLayouts[index] !== undefined
   );
   const directConsumers = valuesByConsumer.filter(
-    (_, index) => seriesLayouts[index] === undefined
+    ({ consumer }, index) => 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,
@@ -21,12 +22,13 @@ import {
   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";
@@ -139,7 +141,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 +186,38 @@ function reverseResolvedScale(scale) {
   };
 }
 
-export function resolveScaleMaterialization({
-  id,
-  scale,
-  channel,
-  consumers,
-  valuesByConsumer,
-  bounds,
-  resolvedScales,
-  markConfigs
-}) {
+export function resolveScaleMaterialization(options) {
+  const {
+    id,
+    scale,
+    channel,
+    consumers,
+    valuesByConsumer,
+    bounds,
+    resolvedScales,
+    markConfigs,
+    thetaScales
+  } = options;
   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
+      }))
+    });
+  }
   const isSequentialColor = channel === "color" &&
     isContinuousColorScaleType(scale.type);
   const isDiscretizedColor = channel === "color" &&
@@ -210,6 +233,9 @@ export function resolveScaleMaterialization({
     !isOrdinalOffset &&
     isDiscretePositionScaleType(scale.type);
 
+  if (isSequentialColor || isDiscretizedColor) {
+    for (const consumer of consumers) validateContinuousColorConsumer(consumer.layer, consumer.encoding, scale);
+  }
   let discretizedScale;
   if (isDiscretizedColor) {
     discretizedScale = resolveDiscretizedColorScale({
@@ -225,8 +251,7 @@ export function resolveScaleMaterialization({
         valuesByConsumer,
         channel,
         scale,
-        id,
-        allValues
+        id
       });
   const seriesLayouts = valuesByConsumer.map(item => item.seriesLayout);
   const seriesDomain = isDiscretizedColor || binnedDomain !== undefined
@@ -247,7 +272,7 @@ export function resolveScaleMaterialization({
   }
   const domain = isDiscretizedColor
     ? discretizedScale.domain
-    : categoryOrderDomain ?? binnedDomain ?? seriesDomain ?? resolveDefaultDomain({
+    : resolveMeasuredRadiusDomain({ scale, channel, allValues }) ?? categoryOrderDomain ?? binnedDomain ?? seriesDomain ?? resolveDefaultDomain({
         scale,
         allValues,
         isOrdinalAppearance,
@@ -267,6 +292,13 @@ export function resolveScaleMaterialization({
     isOrdinalOffset,
     discretizedScale
   });
+  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.`

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.`
+      );
+    }
+  }
+}