ggaction 0.0.17 → 0.0.19

package/src/actions/marks/remove.js

@@ -1,3 +1,4 @@
+import { cartesianAxisOwners, axisTargetArgs } from "../../selectors/axes.js";
 import { ownedChildren, ownership } from "../../selectors/markOwners.js";
 import { isSourceOwnedText } from "../../grammar/text.js";
 import { closedAction } from "../../core/action.js";
@@ -163,6 +164,7 @@ export function removeOwnedMark(program, id, partial = false) {
     next = next.editGraphics({ target: id, remove: true });
   }
   return next
+    ._withoutMaterializationConfig(["guides", "legendGroups", id])
     ._withoutMaterializationConfig(["marks", id])
     ._withContext({
       ...(program.context.currentMark === id ? { currentMark: undefined } : {}),
@@ -182,16 +184,15 @@ function cleanupPositionGuides(program, scales) {
   let next = program;
   for (const channel of POSITION_CHANNELS) {
     const definition = getPositionChannelDefinition(channel);
-    const axis = next.semanticSpec.guides.axis?.[channel];
-    if (
-      axis !== undefined &&
-      scales[channel].has(axis.scale) &&
-      !hasScaleConsumer(next, channel, axis.scale)
-    ) {
-      next = next[REMOVE_AXIS[channel]]({
-        scale: axis.scale,
-        ...(axis.coordinate === undefined ? {} : { coordinate: axis.coordinate })
-      });
+    const owners = ["x", "y"].includes(channel)
+      ? cartesianAxisOwners(next).filter(owner => owner.channel === channel)
+      : [{ id: channel, channel, semantic: next.semanticSpec.guides.axis?.[channel] }];
+    for (const owner of owners) {
+      const axis = owner.semantic;
+      if (axis !== undefined && scales[channel].has(axis.scale) && !hasScaleConsumer(next, channel, axis.scale)) {
+        next = next[REMOVE_AXIS[channel]]({ ...axisTargetArgs(owner.id, channel), scale: axis.scale,
+          ...(axis.coordinate === undefined ? {} : { coordinate: axis.coordinate }) });
+      }
     }
     const grid = next.semanticSpec.guides.grid?.[definition.gridDirection];
     if (
@@ -262,6 +263,7 @@ export const removeMark = /* @__PURE__ */ closedAction(
       if (next.graphicSpec.objects[id] !== undefined) {
         next = next.editGraphics({ target: id, remove: true });
       }
+      next = next._withoutMaterializationConfig(["guides", "legendGroups", id]);
       next = next._withoutMaterializationConfig(["marks", id]);
       next = next._withoutMaterializationConfig(["jitters", id]);
       next = next._withoutMaterializationConfig(["pointPacking", id]);

package/src/actions/marks/rule/actions.js

@@ -298,13 +298,16 @@ const rematerializeRuleMark = /* @__PURE__ */ action(
           properties: item?.properties
         });
         if (box === undefined) throw new Error(`Rule mark "${id}" requires box span owner "${boxSpan}".`);
+        const pixels = resolved.markConfigs[boxSpan]?.boxPlot?.median?.width?.pixels;
         if (layer.encoding?.x?.fieldType === "quantitative") {
           startX = endX = mapped.x[index];
-          startY = box.y;
-          endY = box.y + box.height;
+          const height = pixels ?? box.height;
+          startY = box.y + (box.height - height) / 2;
+          endY = startY + height;
         } else {
-          startX = box.x;
-          endX = box.x + box.width;
+          const width = pixels ?? box.width;
+          startX = box.x + (box.width - width) / 2;
+          endX = startX + width;
           startY = endY = mapped.y[index];
         }
       } else if (mode === "fixed-span") {

package/src/actions/marks/text/actions.js

@@ -3,6 +3,7 @@ import { action } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
 import {
   DEFAULT_TEXT_MARK,
+  TEXT_MARK_STYLE_OPTIONS as STYLE_OPTIONS,
   isSourceOwnedText,
   normalizeTextMarkConfig
 } from "../../../grammar/text.js";
@@ -41,10 +42,6 @@ import { resolveMarkGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
 import { validateItemMissing } from "../../../grammar/itemMissing.js";
 
-const STYLE_OPTIONS = Object.freeze([
-  "fill", "opacity", "fontSize", "fontFamily", "fontWeight",
-  "align", "baseline", "rotation", "dx", "dy"
-]);
 const CREATE_OPTIONS = Object.freeze(["id", "data", "source", "text", "missing", ...STYLE_OPTIONS]);
 const EDIT_OPTIONS = Object.freeze(["target", "missing", ...STYLE_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id", "replayLayout"]);
@@ -195,7 +192,7 @@ const LABEL_OPTIONS = Object.freeze([
 ]);
 
 const ANNOTATION_OPTIONS = Object.freeze([
-  "id", "text", "format", "x", "y", "space", "source", "data", "coordinate", "layout",
+  "id", "text", "format", "anchor", "x", "y", "space", "source", "data", "coordinate", "layout",
   ...STYLE_OPTIONS
 ]);
 
@@ -271,6 +268,15 @@ const createAnnotation = /* @__PURE__ */ action(
   },
   function (args = {}) {
     validateMarkOptions(args, ANNOTATION_OPTIONS, "createAnnotation");
+    if (Object.hasOwn(args, "anchor")) {
+      if (args.anchor !== "plot-center") {
+        throw new Error('createAnnotation anchor must be "plot-center".');
+      }
+      if (["x", "y", "space", "source", "align", "baseline"].some(key => Object.hasOwn(args, key))) {
+        throw new Error("createAnnotation plot-center owns x, y, space, align, and baseline and does not accept source.");
+      }
+      args = { ...args, space: "plot", x: 0.5, y: 0.5, align: "center", baseline: "middle" };
+    }
     if (!Object.hasOwn(args, "text")) {
       throw new Error("createAnnotation requires text.");
     }
@@ -482,6 +488,12 @@ const editTextMark = /* @__PURE__ */ action(
     if (Object.hasOwn(args, "missing") && layer.source !== undefined) {
       throw new Error("Text missing policy requires a row-backed text mark, not source-owned labels.");
     }
+    if (args.inheritColor && layer.source === undefined) {
+      throw new Error("Text inheritColor requires a source-owned label.");
+    }
+    if (Object.hasOwn(args, "fill") && layer.encoding?.color !== undefined) {
+      throw new Error("Text fill conflicts with its color encoding.");
+    }
     const semantic = Object.hasOwn(args, "missing")
       ? this.editSemantic({
           property: `layer[${layer.id}].mark.missing`,

package/src/actions/marks/text/layout.js

@@ -144,6 +144,9 @@ function layoutInputs(program, layer) {
     sourceX: entry.anchor.x,
     sourceY: entry.anchor.y,
     text: entry.graphic.properties.text,
+    lines: entry.graphic.properties.lines,
+    fontFamily: entry.graphic.properties.fontFamily,
+    fontWeight: entry.graphic.properties.fontWeight,
     fontSize: entry.graphic.properties.fontSize,
     textAlign: entry.graphic.properties.textAlign,
     textBaseline: entry.graphic.properties.textBaseline,

package/src/actions/primitives/createGraphics.js

@@ -1,7 +1,8 @@
+import { validateGraphicItemLimit } from "../../core/validation.js";
 import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { freezeOwned } from "../../core/immutable.js";
-import { validateGeneratedItemLimit } from "../../core/validation.js";
+import { resolveGraphicItemCapacity } from "../../selectors/graphicCapacity.js";
 import {
   isDrawableGraphicType,
   isGraphicContainerType,
@@ -118,7 +119,7 @@ const createGraphics = /* @__PURE__ */ closedAction(
       throw new TypeError("createGraphics length must be a non-negative integer.");
     }
     if (length !== undefined) {
-      validateGeneratedItemLimit(length, "createGraphics length");
+      validateGraphicItemLimit(length, resolveGraphicItemCapacity(this, { id, label: "createGraphics length", type: validatedType }));
     }
     if (validatedType === "collection" && length !== undefined) {
       throw new Error("Heterogeneous collections use editGraphics items instead of length.");

package/src/actions/primitives/editGraphics.js

@@ -1,6 +1,7 @@
+import { validateGraphicItemLimit } from "../../core/validation.js";
 import { closedAction } from "../../core/action.js";
 import { cloneAndFreeze, freezeOwned, isPlainObject } from "../../core/immutable.js";
-import { validateGeneratedItemLimit } from "../../core/validation.js";
+import { resolveGraphicItemCapacity } from "../../selectors/graphicCapacity.js";
 import {
   isPrimitiveDrawableGraphicType,
   isStructuralGraphicType,
@@ -43,14 +44,14 @@ function validateCollectionItem(item, ownerId, index) {
   });
 }
 
-function replaceCollectionItems(value, id) {
+function replaceCollectionItems(value, id, program) {
   if (!Array.isArray(value)) throw new TypeError("collection.items must be an array.");
-  validateGeneratedItemLimit(value.length, "collection.items length");
+  validateGraphicItemLimit(value.length, resolveGraphicItemCapacity(program, { id, label: "collection.items length" }));
   return freezeOwned(value.map((item, index) => validateCollectionItem(item, id, index)));
 }
 
-function replaceDrawableItems(value, id, type) {
-  const items = replaceCollectionItems(value, id);
+function replaceDrawableItems(value, id, type, program) {
+  const items = replaceCollectionItems(value, id, program);
   if (!items.every(item => item.type === type)) {
     return freezeOwned({ type: "collection", items });
   }
@@ -102,15 +103,15 @@ function editGeneratedItem(owner, itemIndex, property, value) {
   return freezeOwned({ ...owner, items: freezeOwned(items) });
 }
 
-function editItems(owner, property, value, id) {
+function editItems(owner, property, value, id, program) {
   if (owner.type === "collection" && property === "items") {
-    return freezeOwned({ ...owner, items: replaceCollectionItems(value, id) });
+    return freezeOwned({ ...owner, items: replaceCollectionItems(value, id, program) });
   }
   if (property === "length") {
     if (!Number.isInteger(value) || value < 0) {
       throw new TypeError("Graphic collection length must be a non-negative integer.");
     }
-    validateGeneratedItemLimit(value, "Graphic collection length");
+    validateGraphicItemLimit(value, resolveGraphicItemCapacity(program, { id, label: "Graphic collection length" }));
     const items = owner.items.slice(0, value);
     for (let index = items.length; index < value; index += 1) {
       if (owner.type === "collection") {
@@ -189,6 +190,9 @@ const editGraphics = /* @__PURE__ */ closedAction(
 
     const ownerId = found.kind === "item" ? found.ownerId : found.id;
     const owner = found.kind === "item" ? found.owner : found.object;
+    if (owner.items !== undefined) validateGraphicItemLimit(owner.items.length, resolveGraphicItemCapacity(this, {
+      id: ownerId, label: "Graphic collection length"
+    }));
     const replacesDrawableItems =
       found.kind === "object" && property === "items" &&
       owner.items !== undefined && owner.type !== "collection";
@@ -199,7 +203,7 @@ const editGraphics = /* @__PURE__ */ closedAction(
           : owner.type, property);
     let updated;
     if (replacesDrawableItems) {
-      updated = replaceDrawableItems(value, ownerId, owner.type);
+      updated = replaceDrawableItems(value, ownerId, owner.type, this);
     } else if (found.kind === "item") {
       if (validatedProperty === "length" || validatedProperty === "items") {
         throw new Error(`${validatedProperty} can only target an owning graphic.`);
@@ -212,12 +216,12 @@ const editGraphics = /* @__PURE__ */ closedAction(
         properties: setGraphicProperty(owner.properties, validatedProperty, value)
       });
     } else if (owner.items !== undefined) {
-      updated = editItems(owner, validatedProperty, value, ownerId);
+      updated = editItems(owner, validatedProperty, value, ownerId, this);
     } else if (validatedProperty === "length") {
       if (!Number.isInteger(value) || value < 0) {
         throw new TypeError("Graphic collection length must be a non-negative integer.");
       }
-      validateGeneratedItemLimit(value, "Graphic collection length");
+      validateGraphicItemLimit(value, resolveGraphicItemCapacity(this, { id: ownerId, label: "Graphic collection length" }));
       updated = freezeOwned({
         type: owner.type,
         items: freezeOwned(Array.from({ length: value }, (_, index) => freezeOwned({

package/src/actions/primitives/graphicProperties.js

@@ -1,6 +1 @@
-export function editGraphicProperties(program, target, properties) {
-  for (const [property, value] of Object.entries(properties)) {
-    program = program.editGraphics({ target, property, value });
-  }
-  return program;
-}
+export { editGraphicProperties } from "../../core/graphicProperties.js";

package/src/actions/primitives/semanticAction.js

@@ -57,7 +57,7 @@ function updateEntity(spec, parsed, value) {
         source.schema,
         value[0],
         undefined,
-        { sourceId: source.id, ownerId: parsed.id }
+        { sourceId: source.id, ownerId: parsed.id, sourceTransform: source.transform?.[0] }
       ));
     }
   }
@@ -72,6 +72,7 @@ function updateEntity(spec, parsed, value) {
     const schema = source?.schema !== undefined && current.transform?.length === 1
       ? deriveTransformSchema(source.schema, current.transform[0], value, {
           sourceId: source.id,
+          sourceTransform: source.transform?.[0],
           ownerId: parsed.id
         })
       : inferDatasetSchema(value);
@@ -225,6 +226,31 @@ export function withoutPreviewLayerEncodings(program, { id, channels }) {
   return program._clone({ semanticSpec });
 }
 
+// Composition materialization may retain this native two-scale guide meaning.
+// Use the existing semantic primitives on a private unit adapter; this does not
+// relax the public composition guard or accept arbitrary semantic paths.
+export function synchronizeFacetColorSizeMeaning(program, meaning) {
+  if (program.compositionSpec?.type !== "facet") {
+    throw new Error("Color-size parent meaning requires a facet composition.");
+  }
+  if (meaning !== undefined && (!isPlainObject(meaning) ||
+      Object.keys(meaning).some(key => !["colorScale", "sizeScale", "title"].includes(key)))) {
+    throw new Error("Color-size parent meaning requires its native scale bindings and title.");
+  }
+  let unit = new program.constructor({ semanticSpec: program.semanticSpec, graphicSpec: program.graphicSpec,
+    resolvedScales: program.resolvedScales, materializationConfigs: program.materializationConfigs,
+    context: program.context, trace: program.trace, actionStack: program.actionStack,
+    actionSequence: program._actionSequence });
+  if (unit.semanticSpec.guides.legend?.colorSize !== undefined) {
+    unit = unit.editSemantic({ property: "guide.legend.colorSize", remove: true });
+  }
+  if (meaning !== undefined) for (const [property, value] of Object.entries(meaning)) {
+    unit = unit.editSemantic({ property: `guide.legend.colorSize.${property}`, value });
+  }
+  return program._clone({ semanticSpec: unit.semanticSpec, context: unit.context,
+    trace: unit.trace, actionStack: unit.actionStack, actionSequence: unit._actionSequence });
+}
+
 export function createSemanticPrimitiveAction(validateSemanticValue, planNamedRemoval) {
   return closedAction(
     {

package/src/actions/primitives/semanticValidation/guide.js

@@ -1,3 +1,4 @@
+import {isSizeShapeChannels} from "../../../grammar/legendCombinations.js";
 import { normalizeLegendOrder } from "../../../grammar/categoryOrder.js";
 import { validateUserId } from "../../../core/identifiers.js";
 import { CATEGORICAL_LEGEND_CHANNELS } from "../../../core/vocabulary.js";
@@ -16,7 +17,7 @@ function validateLegend(property, value) {
     throw new Error(`Legend ${property} must not contain duplicates.`);
   }
   if (property === "channels") {
-    if (!value.every(channel => CATEGORICAL_LEGEND_CHANNELS.includes(channel))) {
+    if (!isSizeShapeChannels(value) && !value.every(channel => CATEGORICAL_LEGEND_CHANNELS.includes(channel))) {
       throw new Error("Legend channels support only color, strokeDash, and shape.");
     }
     return;
@@ -26,6 +27,11 @@ function validateLegend(property, value) {
 
 export function validateGuideSemanticValue(_program, parsed, value) {
   const property = parsed.path.at(-1);
+  if (parsed.id === "legend.colorSize") {
+    if(property === "title") validateNonEmptySemanticString(value,"Legend title");
+    else validateUserId(value,"Legend scale id");
+    return;
+  }
   if (parsed.id === "axis.parallel" && property === "titles") {
     validateParallelAxisTitles(value);
     return;
@@ -44,6 +50,10 @@ export function validateGuideSemanticValue(_program, parsed, value) {
       throw new TypeError("Parallel axis scales must contain at least two ids.");
     }
     value.forEach(id => validateUserId(id, "Parallel axis scale id"));
+  } else if (parsed.id.startsWith("axis.") && property === "channel") {
+    if (!["x", "y"].includes(value)) throw new Error("Named Cartesian axis channel requires x or y.");
+  } else if (parsed.id.startsWith("axis.") && property === "position") {
+    if (!["top", "bottom", "left", "right"].includes(value)) throw new Error("Named Cartesian axis position requires a physical side.");
   } else if (property === "title") {
     validateNonEmptySemanticString(value, "Axis title");
   } else {

package/src/actions/primitives/semanticValidation/layer.js

@@ -66,6 +66,14 @@ export function validateLayerSemanticValue(
       throw new Error(`Mark type "${markType}" does not support a missing policy.`);
     }
   }
+  if (property === "mark.orientation" && (findLayer(program, parsed.id)?.mark?.type !== "bar" ||
+      !["vertical", "horizontal"].includes(value))) {
+    throw new Error("Bar orientation must be vertical or horizontal.");
+  }
+  if (property === "mark.blend" &&
+      (findLayer(program, parsed.id)?.mark?.type !== "bar" || value !== "difference")) {
+    throw new Error("Bar blend must be difference; remove the optional intent for normal painting.");
+  }
   if (property === "derivedBindings.regression") {
     if (!value || typeof value !== "object" || Array.isArray(value) ||
         Object.keys(value).length !== 2 || value.mode !== "follow" ||

package/src/actions/regression/create.js

@@ -10,7 +10,7 @@ import {
 } from "./resolve.js";
 
 const REGRESSION_OPTIONS = Object.freeze([
-  "target", "x", "y", "groupBy", "method", "degree", "span",
+  "target", "x", "y", "groupBy", "method", "degree", "span", "robustIterations",
   "confidenceMethod", "level", "confidence", "interval", "band", "line"
   , "predict", "sourceBinding", "missing"
 ]);

package/src/actions/regression/edit.js

@@ -19,9 +19,10 @@ import { findLayer } from "../../selectors/layers.js";
 import { removeOwnedMark } from "../marks/remove.js";
 import { removeOwnedColorLegends } from "../guides/legends/remove.js";
 import { requireRegressionField } from "./resolve.js";
+import { buildSourceRevisionPlan, applyRevisionPlan } from "../data/edit.js";
 
 const OPTIONS = Object.freeze([
-  "target", "data", "x", "y", "groupBy", "method", "degree", "span",
+  "target", "data", "x", "y", "groupBy", "method", "degree", "span", "robustIterations",
   "confidenceMethod", "level", "confidence", "interval", "band", "line"
   , "predict", "sourceBinding", "missing"
 ]);
@@ -111,14 +112,14 @@ function resolveParameters(previous, args) {
   const method = args.method ?? previous.method;
   const raw = { method };
   for (const key of [
-    "degree", "span", "confidenceMethod", "level", "confidence", "interval"
+    "degree", "span", "robustIterations", "confidenceMethod", "level", "confidence", "interval"
   ]) {
     if (Object.hasOwn(args, key)) raw[key] = args[key];
   }
   const inheritsLevel = !Object.hasOwn(raw, "confidence");
   if (method === previous.method && args.interval !== false) {
     for (const key of [
-      "degree", "span", "confidenceMethod", "level", "interval"
+      "degree", "span", "robustIterations", "confidenceMethod", "level", "interval"
     ]) {
       if (
         !Object.hasOwn(raw, key) &&
@@ -128,7 +129,7 @@ function resolveParameters(previous, args) {
         raw[key] = previous[key];
       }
     }
-  } else if (method !== "loess" && previous.method !== "loess" && args.interval !== false) {
+  } else if (!["loess", "exp"].includes(method) && !["loess", "exp"].includes(previous.method) && args.interval !== false) {
     for (const key of ["confidenceMethod", "level", "interval"]) {
       if (
         !Object.hasOwn(raw, key) &&
@@ -295,6 +296,11 @@ export const editRegression = /* @__PURE__ */ closedAction(
     const changesParameters = JSON.stringify(parameters) !==
       JSON.stringify(current.parameters);
     const changesStatistics = changesProvenance || changesParameters;
+    const hasStatistics = this.semanticSpec.datasets.some(dataset =>
+      dataset.source === current.dataId && dataset.transform?.[0]?.type === "regressionStatistics");
+    if (hasStatistics && parameters.method !== "linear") {
+      throw new Error("Remove dependent regression statistics before changing the linear fit method.");
+    }
     const bandPatch = Object.hasOwn(args, "band")
       ? validateBandPatch(args.band)
       : undefined;
@@ -302,14 +308,16 @@ export const editRegression = /* @__PURE__ */ closedAction(
       ? validateLinePatch(args.line)
       : undefined;
     if ((parameters.method === "loess" || parameters.interval === false) && bandPatch !== undefined && bandPatch !== false) {
-      throw new Error("LOESS regression does not support a band object.");
+      throw new Error(parameters.method === "loess"
+        ? "LOESS regression does not support a band object."
+        : "Regression interval false cannot include a band object.");
     }
 
     const hadBand = current.bandId !== undefined;
     const wantsBand = parameters.method !== "loess" && parameters.interval !== false &&
       (bandPatch === false
         ? false
-        : hadBand || bandPatch !== undefined || current.parameters.method === "loess");
+        : hadBand || bandPatch !== undefined || ["loess", "exp"].includes(current.parameters.method));
     const revision = changesStatistics
       ? planDerivedDataRevision(this, {
           owner: owner.id,
@@ -321,6 +329,8 @@ export const editRegression = /* @__PURE__ */ closedAction(
           ]
         })
       : undefined;
+    const statisticsRevision = changesStatistics && hasStatistics
+      ? buildSourceRevisionPlan(this, current.dataId, revision.id) : undefined;
 
     const applyEdit = program => {
       let dataId = current.dataId;
@@ -412,6 +422,8 @@ export const editRegression = /* @__PURE__ */ closedAction(
         }
       });
       if (changesStatistics) {
+        if (statisticsRevision !== undefined) next = applyRevisionPlan(next, undefined,
+          statisticsRevision, { retain: new Set([current.dataId]) });
         next = next.releaseDerivedData(revision.release);
       }
       const binding = findLayer(next, owner.id)?.derivedBindings?.regression;

package/src/actions/regression/resolve.js

@@ -1,3 +1,5 @@
+import { requireStringValue as requireRegressionField } from "../../core/validation.js";
+export { requireStringValue as requireRegressionField } from "../../core/validation.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { findLayer } from "../../selectors/layers.js";
 
@@ -8,12 +10,6 @@ export function requireRegressionObject(value, label) {
   return value;
 }
 
-export function requireRegressionField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 export function findRegressionPoint(program, requested) {
   const eligible = program.semanticSpec.layers.filter(layer =>

package/src/actions/scales/channels.js

@@ -5,6 +5,7 @@ import { normalizePositionScaleChannel } from "../../core/vocabulary.js";
 import { findLayer } from "../../selectors/layers.js";
 import { requireSemanticScale } from "../../selectors/scales.js";
 import { findScaleConsumers } from "./consumers/index.js";
+import { axisScaleBindings } from "../../materialization/coordinateBounds.js";
 
 const DEFINITIONS = Object.freeze({
   editXScale: Object.freeze({
@@ -41,7 +42,7 @@ const DEFINITIONS = Object.freeze({
     channel: "color",
     options: Object.freeze([
       "type", "domain", "range", "emptyDomain", "clamp", "reverse", "palette",
-      "interpolate", "midpoint", "unknown"
+      "interpolate", "whitePoint", "gamma", "midpoint", "base", "exponent", "constant", "unknown"
     ])
   }),
   editStrokeScale: Object.freeze({
@@ -49,7 +50,7 @@ const DEFINITIONS = Object.freeze({
     targetOnly: true,
     options: Object.freeze([
       "type", "domain", "range", "emptyDomain", "clamp", "reverse", "palette",
-      "interpolate", "midpoint", "unknown"
+      "interpolate", "whitePoint", "gamma", "midpoint", "base", "exponent", "constant", "unknown"
     ])
   }),
   editSizeScale: Object.freeze({
@@ -99,9 +100,11 @@ function allConsumers(program) {
 }
 
 function channelScaleIds(program, channel) {
-  return [...new Set(allConsumers(program)
+  return [...new Set([...allConsumers(program)
     .filter(consumer => normalizePositionScaleChannel(consumer.channel) === channel)
-    .map(consumer => consumer.encoding.scale))];
+    .map(consumer => consumer.encoding.scale),
+    ...program.semanticSpec.scales.filter(scale => axisScaleBindings(program, scale.id)
+      .some(binding => binding.channel === channel)).map(scale => scale.id)])];
 }
 
 function requireSingleScale(ids, operation, scope) {
@@ -115,6 +118,8 @@ function requireSingleScale(ids, operation, scope) {
 function validateScaleChannel(program, id, channel, operation) {
   requireSemanticScale(program, id);
   const consumers = findScaleConsumers(program, id);
+  const axes = axisScaleBindings(program, id);
+  if (consumers.length === 0 && axes.length === 1 && axes[0].channel === channel) return id;
   if (consumers.length === 0) {
     throw new Error(`${operation} requires a scale bound to the ${channel} channel.`);
   }

package/src/actions/scales/consumers/families.js

@@ -1,8 +1,9 @@
 import { isPendingMeasuredRadiusConsumer } from "../../../materialization/scales/policies/arc.js";
-import { deriveMeasuredArcValues } from "../../../grammar/arcs.js";
+import { deriveMeasuredArcValues, deriveProportionalArcRadiusValues } from "../../../grammar/arcs.js";
 import { deriveBarAggregates } from "../../../grammar/bars/aggregate.js";
 import {
   BAR_GRAINS,
+  resolveBarChannels,
   resolveBarGrain
 } from "../../../grammar/bars/policy.js";
 import {
@@ -28,9 +29,15 @@ function lineDerivationOptions(program, consumer, dataset) {
 }
 
 export function resolveMarkFamilyConsumerValues(program, consumer, dataset) {
-  if (consumer.layer.mark?.type === "arc" && consumer.channel === "radius" &&
-    findScale(program, consumer.encoding.scale).radialMapping !== undefined) {
-    return { matched: true, values: isPendingMeasuredRadiusConsumer(consumer) ? [] : deriveMeasuredArcValues(dataset.values, consumer.layer).map(item => item.radius) };
+  if (consumer.layer.mark?.type === "arc" && consumer.channel === "radius") {
+    let derive;
+    if (findScale(program, consumer.encoding.scale).radialMapping !== undefined) derive = deriveMeasuredArcValues;
+    else if (consumer.layer.encoding?.theta?.fieldType === "quantitative" ||
+      consumer.layer.encoding?.theta?.aggregate !== undefined || consumer.encoding.aggregate !== undefined) {
+      derive = deriveProportionalArcRadiusValues;
+    }
+    if (derive !== undefined) return { matched: true, values: isPendingMeasuredRadiusConsumer(consumer)
+      ? [] : derive(dataset.values, consumer.layer).map(item => item.radius) };
   }
 
   if (consumer.layer.mark?.type === "rect") {
@@ -44,6 +51,10 @@ export function resolveMarkFamilyConsumerValues(program, consumer, dataset) {
     };
   }
   const { layer, channel } = consumer;
+  if (resolveBarGrain(layer) === BAR_GRAINS.centered &&
+      channel === resolveBarChannels(layer).measure && layer.encoding[`${channel}2`] === undefined) {
+    return { matched: true, values: [0, ...dataset.values.map(row => row[consumer.encoding.field])] };
+  }
   const encoding = layer.encoding ?? {};
   const appearance = ["stroke", "strokeWidth", "opacity"].includes(channel);
   if (
@@ -75,7 +86,7 @@ export function resolveMarkFamilyConsumerValues(program, consumer, dataset) {
         : channel === "x" ? derived.xValues : derived.yValues
     };
   }
-  if (resolveBarGrain(consumer.layer) === BAR_GRAINS.aggregate) {
+  if (resolveBarGrain(consumer.layer) === BAR_GRAINS.aggregate && ["x", "y", "color"].includes(consumer.channel)) {
     const derived = deriveBarAggregates(dataset.values, consumer.layer);
     if (consumer.channel === "color") {
       return {

package/src/actions/scales/create.js

@@ -38,7 +38,7 @@ const CREATE_SCALE_OPTIONS = Object.freeze([
   "padding",
   "align",
   "palette",
-  "interpolate", "midpoint",
+  "interpolate", "whitePoint", "gamma", "midpoint",
   "radialMapping", "unknown"
 ]);
 
@@ -87,14 +87,18 @@ export const createScale = /* @__PURE__ */ action(
     validateOptions(args);
     const id = validateUserId(args.id, "Scale id");
     const type = validateScaleType(args.type ?? "linear");
-    const colorType = isColorScaleType(type);
+    const colorType = isColorScaleType(type) && (
+      !["log", "pow", "sqrt", "symlog"].includes(type) || args.palette !== undefined ||
+      args.interpolate !== undefined || (Array.isArray(args.range) && typeof args.range[0] === "string") ||
+      args.range?.palette !== undefined
+    );
     if (args.palette !== undefined && args.range !== undefined) {
       throw new Error("Color scale cannot specify both palette and range.");
     }
     if (args.palette !== undefined && !colorType) {
       throw new Error(`Scale type "${type}" does not support palette.`);
     }
-    if (args.interpolate !== undefined && type !== "sequential") {
+    if (args.interpolate !== undefined && !colorType) {
       throw new Error(`Scale type "${type}" does not support interpolate.`);
     }
     const requestedRange = args.palette === undefined
@@ -129,6 +133,7 @@ export const createScale = /* @__PURE__ */ action(
         })
       : normalizeScaleDefinition({
           type,
+          color: colorType,
           patch: {
             ...args,
             ...(requestedRange === undefined ? {} : { range: requestedRange })
@@ -143,7 +148,7 @@ export const createScale = /* @__PURE__ */ action(
           validateRange: (scaleType, value) =>
             isDiscretizedColorScaleType(scaleType)
               ? validateDiscretizedColorRange(value)
-              : isContinuousColorScaleType(scaleType)
+              : colorType && isContinuousColorScaleType(scaleType)
                 ? validateSequentialColorRange(value)
                 : scaleType === "ordinal"
                   ? validateOrdinalRange(value)
@@ -166,7 +171,7 @@ export const createScale = /* @__PURE__ */ action(
 
     for (const property of [
       "emptyDomain", "nice", "zero", "clamp", "reverse", "base", "exponent", "constant",
-      "paddingInner", "paddingOuter", "padding", "align", "interpolate", "midpoint",
+      "paddingInner", "paddingOuter", "padding", "align", "interpolate", "whitePoint", "gamma", "midpoint",
       "radialMapping", "unknown"
     ]) {
       if (definition[property] === undefined) continue;