ggaction 0.0.16 → 0.0.18

package/src/actions/data/revise.js

@@ -6,16 +6,48 @@ import { requireLayer } from "../../selectors/layers.js";
 import { applyRevisionPlan, buildSourceRevisionPlan } from "./edit.js";
 import { resolveStoredSelection } from "../../materialization/selection/state.js";
 import { withGuideLayoutTransaction } from "../../materialization/guides/layout.js";
+import { assertFieldsAvailable } from "../../grammar/datasetSchema.js";
 
 let reviseFacet;
 
+function layerInputFields(layer) {
+  const fields = [];
+  const add = value => {
+    if (typeof value === "string" && value.length > 0) fields.push(value);
+  };
+  for (const encoding of Object.values(layer.encoding ?? {})) {
+    if (!encoding || typeof encoding !== "object") continue;
+    add(encoding.field);
+    add(encoding.weight);
+    add(encoding.key);
+    add(encoding.pathOrder?.field);
+    add(encoding.categoryOrder?.by?.field);
+    for (const field of encoding.fields ?? []) add(field);
+    for (const dimension of encoding.dimensions ?? []) add(dimension.field);
+  }
+  return [...new Set(fields)];
+}
+
 export function registerFacetDataRevision(handler) {
   reviseFacet = handler;
 }
 
-export function reviseUnitData(program, { source, id, values }) {
+export function reviseUnitData(program, { source, id, values, schema }) {
   const plan = buildSourceRevisionPlan(program, source, id);
-  const created = program.createData({ id, values });
+  const original = requireDataset(program, source);
+  const inheritedSchema = schema ?? (original.schema?.origin === "declared"
+    ? { fields: original.schema.fields.map(({ name, storageType, nullable, optional }) => ({
+        name, storageType, nullable, optional
+      })) }
+    : undefined);
+  const created = program.createData({ id, values, ...(inheritedSchema === undefined ? {} : { schema: inheritedSchema }) });
+  const revisedSource = requireDataset(created, id);
+  for (const layer of program.semanticSpec.layers.filter(layer => layer.data === source)) {
+    assertFieldsAvailable(revisedSource.schema, layerInputFields(layer), {
+      data: id,
+      operation: "reviseData"
+    });
+  }
   const next = withGuideLayoutTransaction(created, candidate =>
     applyRevisionPlan(candidate, undefined, plan, { retain: new Set([source]) }));
   for (const [selection, config] of Object.entries(next.materializationConfigs.selections ?? {})) {
@@ -27,7 +59,7 @@ export function reviseUnitData(program, { source, id, values }) {
 }
 
 export const reviseData = /* @__PURE__ */ closedAction(
-  { op: "reviseData", description: "Revise source data and its dependent chart.", scope: "any" }, ["source", "id", "values"],
+  { op: "reviseData", description: "Revise source data and its dependent chart.", scope: "any" }, ["source", "id", "values", "schema"],
   function (args = {}) {
     const source = validateUserId(args.source, "Source dataset id");
     const id = validateUserId(args.id, "Revision dataset id");
@@ -39,8 +71,8 @@ export const reviseData = /* @__PURE__ */ closedAction(
       throw new Error(`Source "${source}" must be a materialized original dataset.`);
     }
     const apply = this.compositionSpec === undefined
-      ? program => reviseUnitData(program, { source, id, values: args.values }).program
-      : program => reviseFacet(program, { source, id, values: args.values });
+      ? program => reviseUnitData(program, { source, id, values: args.values, schema: args.schema }).program
+      : program => reviseFacet(program, { source, id, values: args.values, schema: args.schema });
     // The entire dependent materialization must succeed before returning a revision.
     apply(this);
     return apply(this);

package/src/actions/data/shared.js

@@ -5,6 +5,12 @@ import {
   findDataset,
   resolveDatasetReference
 } from "../../selectors/datasets.js";
+import {
+  assertFieldsAvailable,
+  deriveTransformSchema,
+  transformInputFields,
+  validateRowsAgainstSchema
+} from "../../grammar/datasetSchema.js";
 
 export const MATERIALIZE_OPTIONS = Object.freeze(["id"]);
 
@@ -37,17 +43,39 @@ export function derivedMaterializer(op, description, type, derive, resolve) {
       args.id,
       type
     );
+    assertFieldsAvailable(source.schema, transformInputFields(transform), {
+      data: source.id,
+      operation: op
+    });
     const result = derive(source.values, transform);
+    const values = Array.isArray(result) ? result : result.values;
+    const schema = deriveTransformSchema(source.schema, transform, values, {
+      sourceId: source.id,
+      ownerId: id
+    });
+    validateRowsAgainstSchema(values, schema, `Derived dataset "${id}"`);
     const program = resolve === undefined
       ? this
       : this.editSemantic({
           property: `dataset[${id}].transform`,
           value: resolve(result, transform)
         });
-    return program.editSemantic({
+    let next = program.editSemantic({
       property: `dataset[${id}].values`,
-      value: Array.isArray(result) ? result : result.values
+      value: values
     });
+    if (!Array.isArray(result) && result.report !== undefined) {
+      const report = {
+        ...result.report,
+        owner: { kind: "data", id },
+        inputs: [{ kind: "data", id: source.id }]
+      };
+      next = next._withMaterializationConfig(
+        ["calculations", "datasets", id],
+        report
+      );
+    }
+    return next;
   });
 }
 
@@ -59,11 +87,12 @@ export function derivedCreator(
   sourceLabel,
   transform,
   materialize,
-  requireSource = false
+  requireSource = false,
+  defaultId
 ) {
   return action({ op, description }, function (args = {}) {
     validateKeys(args, options, op);
-    const id = validateUserId(args.id, idLabel);
+    const id = validateUserId(args.id === undefined ? defaultId : args.id, idLabel);
     const requestedSource = validateUserId(
       requireSource ? args.source : args.source ?? this.context.currentData,
       sourceLabel

package/src/actions/data/sort.js

@@ -0,0 +1,21 @@
+import { deriveSortedRows, normalizeSortTransform } from "../../grammar/sort.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
+
+const OPTIONS = Object.freeze(["id", "source", "sortBy"]);
+
+export const materializeSortedData = /* @__PURE__ */ derivedMaterializer(
+  "materializeSortedData",
+  "Materialize one immutable stable sorted dataset.",
+  "sort",
+  deriveSortedRows
+);
+
+export const createSortedData = /* @__PURE__ */ derivedCreator(
+  "createSortedData",
+  "Create reusable rows in a stable explicit order.",
+  OPTIONS,
+  "Sorted dataset id",
+  "Sorted source dataset id",
+  normalizeSortTransform,
+  "materializeSortedData"
+);

package/src/actions/data/stack.js

@@ -22,5 +22,7 @@ export const createStackData = /* @__PURE__ */ derivedCreator(
   "Stack dataset id",
   "Stack source dataset id",
   normalizeStackTransform,
-  "materializeStackData"
+  "materializeStackData",
+  false,
+  "stacked"
 );

package/src/actions/data/summary.js

@@ -5,7 +5,7 @@ import {
 import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "source", "groupBy", "aggregates", "members", "weight"
+  "id", "source", "groupBy", "aggregates", "members", "weight", "missing", "empty"
 ]);
 
 export const materializeSummaryData = /* @__PURE__ */ derivedMaterializer(

package/src/actions/encodings/angle.js

@@ -5,6 +5,8 @@ import {
   setEncodingProperties,
   validateOptions
 } from "./shared.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const OPTIONS = Object.freeze(["target", "value", "field", "fieldType"]);
 
@@ -29,7 +31,7 @@ export const encodeAngle = /* @__PURE__ */ action(
     if (hasValue && args.fieldType !== undefined) {
       throw new Error("Constant angle does not accept fieldType.");
     }
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       ["point", "tick"],
@@ -39,6 +41,7 @@ export const encodeAngle = /* @__PURE__ */ action(
       throw new TypeError("encodeAngle value must be finite degrees.");
     }
     if (hasField) {
+      const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
       const fieldType = args.fieldType ?? "quantitative";
       if (fieldType !== "quantitative") {
         throw new Error("encodeAngle requires a quantitative field.");

package/src/actions/encodings/appearance.js

@@ -1,9 +1,8 @@
+import { canMaterializeBar } from "../../materialization/marks/index.js";
 import { action } from "../../core/action.js";
 import { validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
 import { assertEncodingSelectionCompatibility } from "../../materialization/selection/compatibility.js";
 import {
-  readNominalField,
-  readQuantitativeField,
   readScaleField,
   validateOpacityValue
 } from "../../grammar/scales/index.js";
@@ -25,6 +24,8 @@ import {
   setEncodingProperties,
   validateOptions
 } from "./shared.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const RADIUS_OPTIONS = Object.freeze(["value", "target"]);
 const REMOVE_RADIUS_OPTIONS = Object.freeze(["target"]);
@@ -34,16 +35,17 @@ const OPACITY_OPTIONS = Object.freeze([
 const FIELD_OPTIONS = Object.freeze(["field", "target", "fieldType", "scale"]);
 function encodeAppearanceField(program, channel, args, operation) {
   validateOptions(args, FIELD_OPTIONS, operation);
-  const { id: target, dataset, layer } = resolveTarget(
+  const { id: target, dataset: sourceDataset, layer } = resolveTarget(
     program,
     args.target,
     ["point"],
     "point mark"
   );
-  const expectedFieldType = channel === "shape" ? "nominal" : "quantitative";
-  const fieldType = args.fieldType ?? expectedFieldType;
-  if (fieldType !== expectedFieldType) {
-    throw new Error(`${operation} requires a ${expectedFieldType} field.`);
+  const fieldTypes = channel === "shape" ? ["nominal"] : ["quantitative", "nominal", "ordinal"];
+  const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
+  const fieldType = args.fieldType ?? fieldTypes[0];
+  if (!fieldTypes.includes(fieldType)) {
+    throw new Error(`${operation} requires a ${fieldTypes.join(" or ")} field.`);
   }
   if (channel === "size" && program.markConfigs[target]?.radius !== undefined) {
     throw new Error("encodeSize cannot be combined with a constant radius.");
@@ -56,17 +58,12 @@ function encodeAppearanceField(program, channel, args, operation) {
   const scale = resolveAppearanceScaleDefinition(
     program,
     channel,
-    requestedScale
+    requestedScale,
+    fieldType
   );
-  if (Object.hasOwn(scale, "unknown")) {
-    readScaleField(dataset.values, args.field, fieldType, {
-      allowUnknown: true
-    });
-  } else if (channel === "shape") {
-    readNominalField(dataset.values, args.field);
-  } else {
-    readQuantitativeField(dataset.values, args.field);
-  }
+  readScaleField(dataset.values, args.field, fieldType, {
+    allowUnknown: Object.hasOwn(scale, "unknown")
+  });
 
   let next = setEncodingProperties(program, target, channel, {
     field: args.field,
@@ -149,7 +146,7 @@ const removePointRadius = /* @__PURE__ */ action(
 const encodeSize = /* @__PURE__ */ action(
   {
     op: "encodeSize",
-    description: "Encode a quantitative field as equal-area point size."
+    description: "Encode a field as equal-area point size."
   },
   function (args = {}) {
     return encodeAppearanceField(this, "size", args, "encodeSize");
@@ -181,6 +178,17 @@ const clearOpacityEncoding = /* @__PURE__ */ action(
   }
 );
 
+function withoutConstantOpacity(program, target) {
+  const { opacity, ...config } = program.markConfigs[target] ?? {};
+  void opacity;
+  if (config.barAppearance?.opacity !== undefined) {
+    const { opacity: barOpacity, ...appearance } = config.barAppearance;
+    void barOpacity;
+    config.barAppearance = appearance;
+  }
+  return program._withMarkConfig(target, config);
+}
+
 const encodeOpacity = /* @__PURE__ */ action(
   {
     op: "encodeOpacity",
@@ -196,17 +204,16 @@ const encodeOpacity = /* @__PURE__ */ action(
     if (hasValue && (args.fieldType !== undefined || args.scale !== undefined)) {
       throw new Error("Constant opacity does not accept fieldType or scale.");
     }
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
-      ["point", "rule", "line"],
-      "point, rule or line mark"
+      ["point", "rule", "line", "bar"],
+      "point, rule, line or bar mark"
     );
     if (hasValue) {
       validateOpacityValue(args.value, "encodeOpacity");
       assertEncodingSelectionCompatibility(this, target, ["opacity"]);
-      const { opacity, ...config } = this.markConfigs[target] ?? {};
-      void opacity;
+      const config = withoutConstantOpacity(this, target).markConfigs[target];
       const withoutLegend = this.guideConfigs.legend?.opacity?.target === target
         ? this.removeOpacityLegend()
         : this;
@@ -217,11 +224,17 @@ const encodeOpacity = /* @__PURE__ */ action(
       if (layer.mark.type === "line") {
         return rematerializeEncoding(next, target, "opacity", undefined, layer);
       }
+      if (layer.mark.type === "bar") {
+        return canMaterializeBar(next, findLayer(next, target))
+          ? applyDetachedScaleRematerialization(next.rematerializeBarMark({ id: target }), [layer])
+          : next;
+      }
       const materialized = layer.mark.type === "rule"
         ? next.rematerializeRuleMark({ id: target })
         : next.rematerializePointMark({ id: target });
       return applyDetachedScaleRematerialization(materialized, [layer]);
     }
+    const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
     const fieldType = args.fieldType ?? "quantitative";
     if (fieldType !== "quantitative") {
       throw new Error("encodeOpacity requires a quantitative field.");
@@ -240,17 +253,13 @@ const encodeOpacity = /* @__PURE__ */ action(
         ...layer, encoding: { ...layer.encoding, opacity: { field: args.field, fieldType } }
       });
     }
-    if (Object.hasOwn(scale, "unknown")) {
-      readScaleField(dataset.values, args.field, fieldType, {
-        allowUnknown: true
-      });
-    } else {
-      readQuantitativeField(dataset.values, args.field);
-    }
+    readScaleField(dataset.values, args.field, fieldType, {
+      allowUnknown: Object.hasOwn(scale, "unknown")
+    });
     const { opacity, ...config } = this.markConfigs[target] ?? {};
     void opacity;
     let next = setEncodingProperties(
-      this._withoutMaterializationConfig(["marks", target, "opacity"]),
+      withoutConstantOpacity(this, target),
       target,
       "opacity",
       { field: args.field, fieldType, scale: scale.id }
@@ -258,6 +267,9 @@ const encodeOpacity = /* @__PURE__ */ action(
     next = applyEncodingScale(next, scale, requestedScale, {
       reassignment: previous?.scale === scale.id
     });
+    if (layer.mark.type === "bar" && !canMaterializeBar(next, findLayer(next, target))) {
+      return next.rematerializeScale({ id: scale.id });
+    }
     return rematerializeEncoding(next, target, "opacity", scale.id, layer);
   }
 );

package/src/actions/encodings/barWidth.js

@@ -4,11 +4,33 @@ import {
   BAR_GRAINS,
   resolveBarColorLayout,
   resolveBarOffsetChannel,
+  resolveBarChannels,
   resolveBarGrain
 } from "../../grammar/bars/policy.js";
 import { normalizeBarWidth } from "../../grammar/bars/geometry.js";
+import { applyMaterializationPlan } from "../../materialization/dependencies.js";
+import {
+  getScaleConsumerMarkSteps,
+  getSourceDependentMarkSteps
+} from "../../materialization/marks/index.js";
+
+function rematerializeWidth(program, target, layer, width) {
+  const next = program._withMarkConfig(target, {
+    ...program.markConfigs[target], barWidth: width
+  }).rematerializeBarMark({ id: target });
+  const category = resolveBarChannels(layer)?.category;
+  const encoding = layer.encoding?.[category];
+  if (encoding?.fieldType !== "temporal") return next;
+  const marks = getScaleConsumerMarkSteps(next, [encoding.scale])
+    .filter(step => step.args.id !== target);
+  return applyMaterializationPlan(next, [
+    ...marks,
+    ...[target, ...marks.map(step => step.args.id)]
+      .flatMap(id => getSourceDependentMarkSteps(next, id))
+  ]);
+}
 
-const OPTIONS = Object.freeze(["band", "pixels", "target"]);
+const OPTIONS = Object.freeze(["band", "pixels", "interval", "target"]);
 
 const encodeBarWidth = /* @__PURE__ */ action(
   {
@@ -26,22 +48,30 @@ const encodeBarWidth = /* @__PURE__ */ action(
     const layout = resolveBarColorLayout(layer);
     const width = normalizeBarWidth(
       args,
-      this.markConfigs[target]?.barWidth
+      this.markConfigs[target]?.barWidth ?? (layer.mark.orientation === undefined ? undefined : { pixels: 5 })
     );
     const grouped = layout === "group";
     const offsetChannel = resolveBarOffsetChannel(layer);
     const grain = resolveBarGrain(layer);
+    if (layer.mark.orientation !== undefined && width.band !== undefined) {
+      throw new Error("Numeric-center bars require pixel width.");
+    }
     if (grain === undefined && this.markConfigs[target]?.boxPlot === undefined && (
       layer.encoding?.x === undefined || layer.encoding?.y === undefined
     )) {
       return this._withMarkConfig(target, { ...this.markConfigs[target], barWidth: width });
     }
+    if (width.interval !== undefined && grain !== undefined) {
+      const category = resolveBarChannels(layer)?.category;
+      if (grain !== BAR_GRAINS.aggregate || grouped || layer.encoding?.[category]?.fieldType !== "temporal") {
+        throw new Error("Bar interval width requires ungrouped aggregate temporal categories.");
+      }
+    }
     if (grain === BAR_GRAINS.histogram) {
       throw new Error("encodeBarWidth requires an aggregate or ranged category slot, not histogram bins.");
     }
-    if (grain === BAR_GRAINS.ranged) {
-      return this._withMarkConfig(target, { ...this.markConfigs[target], barWidth: width })
-        .rematerializeBarMark({ id: target });
+    if ([BAR_GRAINS.ranged, BAR_GRAINS.centered].includes(grain)) {
+      return rematerializeWidth(this, target, layer, width);
     }
     if (
       grain !== BAR_GRAINS.aggregate ||
@@ -56,12 +86,7 @@ const encodeBarWidth = /* @__PURE__ */ action(
       );
     }
 
-    return this
-      ._withMarkConfig(target, {
-        ...this.markConfigs[target],
-        barWidth: width
-      })
-      .rematerializeBarMark({ id: target });
+    return rematerializeWidth(this, target, layer, width);
   }
 );
 

package/src/actions/encodings/channels.js

@@ -155,7 +155,6 @@ function resolveScaleOnly(program, id) {
   }
   const consumers = findScaleConsumers(program, id);
   if (
-    semanticScale.radialMapping !== undefined &&
     consumers.length > 0 &&
     consumers.every(isPendingMeasuredRadiusConsumer)
   ) {

package/src/actions/encodings/color/continuous.js

@@ -26,6 +26,8 @@ import {
 } from "./policy.js";
 
 import { applyTemporalUnit } from "../temporal.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../../grammar/itemMissing.js";
 
 export function encodeContinuousColor(program, args) {
   if (!["quantitative", "temporal"].includes(args.fieldType)) {
@@ -34,12 +36,13 @@ export function encodeContinuousColor(program, args) {
   if (args.layout !== undefined) {
     throw new Error("Continuous color does not support layout.");
   }
-  const { id: target, dataset, layer } = resolveTarget(
+  const { id: target, dataset: sourceDataset, layer } = resolveTarget(
     program,
     args.target,
-    ["point", "bar", "rect"],
+    ["point", "bar", "rect", "text"],
     "continuous color mark"
   );
+  const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
   assertNoConstantColor(program, layer);
   const temporalUnit = resolveTemporalUnit(args, args.fieldType, layer.encoding?.color);
   const requestedScale = resolveReassignmentScaleOptions(

package/src/actions/encodings/color/index.js

@@ -38,6 +38,8 @@ import {
 } from "./policy.js";
 
 import { applyTemporalUnit } from "../temporal.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../../grammar/itemMissing.js";
 
 const encodeColor = /* @__PURE__ */ action(
   {
@@ -58,12 +60,13 @@ const encodeColor = /* @__PURE__ */ action(
     }
     const fieldType = validateCategoricalFieldType(requestedFieldType);
     resolveTemporalUnit(args, fieldType);
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
-      ["point", "line", "bar", "area", "arc", "rect"],
+      ["point", "line", "bar", "area", "arc", "rect", "text"],
       "color mark"
     );
+    const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
     assertNoConstantColor(this, layer);
     const densityTransform = dataset.transform?.length === 1 &&
       dataset.transform[0].type === "density"

package/src/actions/encodings/color/policy.js

@@ -20,6 +20,9 @@ export function resolveColorScaleOptions(args) {
 }
 
 export function assertNoConstantColor(program, layer) {
+  if (layer.mark.type === "text" && layer.source !== undefined) {
+    throw new Error("Source-owned text uses inheritColor or constant fill; field color requires row-backed text.");
+  }
   const config = program.markConfigs[layer.id];
   const hasConstant = {
     point: config?.fill !== undefined,
@@ -27,7 +30,8 @@ export function assertNoConstantColor(program, layer) {
     area: config?.errorBand?.fill !== undefined,
     bar: config?.barAppearance?.fill !== undefined,
     arc: config?.fill !== undefined,
-    rect: config?.fillExplicit === true
+    rect: config?.fillExplicit === true,
+    text: config?.fillExplicit === true
   }[layer.mark.type] ?? false;
   if (hasConstant) {
     throw new Error(
@@ -58,15 +62,18 @@ export function resolveColorLayout(layer, requested, barGrain) {
     layer.mark.type === "bar"
       ? barGrain === BAR_GRAINS.histogram
         ? "stack"
-        : barGrain === BAR_GRAINS.ranged ? "overlay" : "group"
+        : [BAR_GRAINS.ranged, BAR_GRAINS.centered].includes(barGrain) ? "overlay" : "group"
       : layer.mark.type === "area"
         ? "overlay"
         : undefined
   );
 
-  if (["point", "line", "rect"].includes(layer.mark.type) && layout !== undefined) {
+  if (["point", "line", "rect", "text"].includes(layer.mark.type) && layout !== undefined) {
     throw new Error(`Color layout is not supported for ${layer.mark.type} marks.`);
   }
+  if (barGrain === BAR_GRAINS.centered && layout !== "overlay") {
+    throw new Error("Numeric-center bars support only overlay layout.");
+  }
   if (layer.mark.type === "area" && layout === "group") {
     throw new Error('Area color layout does not support "group".');
   }

package/src/actions/encodings/density/resolve.js

@@ -1,12 +1,7 @@
+export { requireStringValue as requireDensityField } from "../../../core/validation.js";
 import { isPlainObject } from "../../../core/immutable.js";
 import { findSemanticScale } from "../../../selectors/scales.js";
 
-export function requireDensityField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 export function resolveDensityScaleOptions(value, defaults, label) {
   if (value !== undefined && !isPlainObject(value)) {

package/src/actions/encodings/offset.js

@@ -18,6 +18,8 @@ import {
   resolveBarChannels,
   resolveBarGrain
 } from "../../grammar/bars/policy.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const ENCODING_OPTIONS = Object.freeze([
   "field", "target", "fieldType", "scale", "paddingInner", "paddingOuter"
@@ -33,12 +35,13 @@ function createOffsetEncoding(channel) {
     function (args = {}) {
       validateOptions(args, ENCODING_OPTIONS, operation);
       const fieldType = validateCategoricalFieldType(args.fieldType ?? "nominal");
-      const { id: target, dataset, layer } = resolveTarget(
+      const { id: target, dataset: sourceDataset, layer } = resolveTarget(
         this,
         args.target,
         ["bar", "point", "rule"],
         "offset-compatible mark"
       );
+      const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
 
       if (layer.mark.type === "bar") {
         const channels = resolveBarChannels(layer);

package/src/actions/encodings/position/policies/arc.js

@@ -11,11 +11,6 @@ export function resolveArcPositionPolicy({ channel, args, fieldType, layer }) {
     throw new Error(`Arc ${channel} encoding does not support stack.`);
   }
   if (channel === "radius") {
-    if (layer.encoding?.theta?.fieldType === "quantitative") {
-      throw new Error(
-        "Arc radius encoding cannot be combined with quantitative theta."
-      );
-    }
     if (args.mapping !== undefined) {
       validateRadialMapping(args.mapping);
       if (fieldType !== "quantitative" || !["count", "sum"].includes(args.aggregate)) {
@@ -30,7 +25,16 @@ export function resolveArcPositionPolicy({ channel, args, fieldType, layer }) {
       return { ...emptyPositionPolicy(), aggregate: args.aggregate };
     }
     if (args.aggregate !== undefined) {
-      throw new Error("Arc radius encoding does not support aggregate.");
+      if (!["count", "sum"].includes(args.aggregate)) throw new Error("Arc radius aggregate supports count or sum.");
+      const theta = layer.encoding?.theta;
+      if (theta !== undefined && !["count", "sum"].includes(theta.aggregate)) {
+        throw new Error("Grouped arc radius requires aggregated categorical theta.");
+      }
+      if (args.aggregate === "count" && Object.hasOwn(args, "field")) {
+        throw new Error("Arc radius count does not accept a field.");
+      }
+      if (args.weight !== undefined) throw new Error("Arc radius encoding does not support weight.");
+      return { ...emptyPositionPolicy(), aggregate: args.aggregate };
     }
     if (args.weight !== undefined) {
       throw new Error("Arc radius encoding does not support weight.");
@@ -38,10 +42,8 @@ export function resolveArcPositionPolicy({ channel, args, fieldType, layer }) {
     return emptyPositionPolicy();
   }
   if (fieldType === "quantitative") {
-    if (layer.encoding?.radius !== undefined) {
-      throw new Error(
-        "Quantitative arc theta cannot be combined with radius encoding."
-      );
+    if (layer.encoding?.radius?.aggregate !== undefined) {
+      throw new Error("Grouped arc radius requires aggregated categorical theta.");
     }
     if (args.aggregate !== undefined) {
       throw new Error("Quantitative arc theta does not support aggregate.");

package/src/actions/encodings/position/policies/area.js

@@ -26,16 +26,16 @@ export function resolveAreaPositionPolicy({
   const density = dataset.transform?.find(transform => transform.type === "density");
   if (["nominal", "ordinal"].includes(fieldType)) {
     if (
-      density?.placement?.type !== "category" ||
+      density !== undefined && (density.placement?.type !== "category" ||
       density.placement.channel !== channel ||
-      density.placement.categoryField !== field
+      density.placement.categoryField !== field)
     ) {
       throw new Error(
         "Categorical area position requires a matching category density placement."
       );
     }
     if (args.aggregate !== undefined || args.bin !== undefined || args.stack !== undefined) {
-      throw new Error("Categorical density position does not support aggregate, bin, or stack.");
+      throw new Error("Categorical area position does not support aggregate, bin, or stack.");
     }
     return emptyPositionPolicy();
   }