ggaction 0.0.11 → 0.0.13

package/src/actions/marks/arc/actions.js

@@ -51,7 +51,7 @@ function normalizeConfig(args, previous = {}, { allowStrokeRemoval = false } = {
   let config = {
     ...previous,
     ...(Object.hasOwn(args, "innerRadius")
-      ? { innerRadius: validateInnerRadius(args.innerRadius) }
+      ? { innerRadius: validateInnerRadius(args.innerRadius), innerRadiusExplicit: true }
       : {}),
     ...(Object.hasOwn(args, "padAngle")
       ? { padAngle: validateNonNegativeFinite(args.padAngle, "Arc padAngle") }

package/src/actions/marks/area/actions.js

@@ -1,3 +1,4 @@
+import { validateAreaMissing } from "../../../grammar/areaEndpoints.js";
 import { action } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
 import {
@@ -30,8 +31,8 @@ import { resolveAreaMaterialization } from "./materialize.js";
 const AREA_OPTIONS = Object.freeze([
   "fill", "opacity", "stroke", "strokeWidth", "curve"
 ]);
-const CREATE_OPTIONS = Object.freeze(["id", "data", ...AREA_OPTIONS]);
-const EDIT_OPTIONS = Object.freeze(["target", ...AREA_OPTIONS]);
+const CREATE_OPTIONS = Object.freeze(["id", "data", "missing", ...AREA_OPTIONS]);
+const EDIT_OPTIONS = Object.freeze(["target", "missing", ...AREA_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id", "scales"]);
 const STROKE_FROM_FILL_OPTIONS = Object.freeze(["id", "strokeWidth"]);
 
@@ -69,6 +70,10 @@ const createAreaMark = action(
       ...(args.data === undefined && this.context.currentData === undefined &&
         inherited?.data !== undefined ? { data: inherited.data } : {})
     });
+    const missing = validateAreaMissing(args.missing);
+    if (missing === "break" && ["density", "horizon"].some(type => findUpstreamTransform(this, findDataset(this, data), type))) {
+      throw new Error("Area missing:break does not reinterpret density or horizon data.");
+    }
     const fill = validateNonEmptyString(args.fill ?? DEFAULT_COLORS.mark, "Area fill");
     const opacity = validateUnitInterval(args.opacity ?? 0.2, "Area opacity");
     const curve = validateCurveInterpolation(args.curve ?? "linear");
@@ -77,6 +82,7 @@ const createAreaMark = action(
     let created = this
       .editSemantic({ property: `layer[${id}].mark.type`, value: "area" })
       .editSemantic({ property: `layer[${id}].data`, value: data });
+    if (Object.hasOwn(args, "missing")) created = created.editSemantic({ property: `layer[${id}].mark.missing`, value: missing });
     created = applyLayeredMarkInheritance(created, id, inherited);
     created = created
       .createGraphics({
@@ -218,7 +224,7 @@ const editAreaMark = action(
   },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editAreaMark");
-    const changes = ["fill", "opacity", "stroke", "strokeWidth", "curve"];
+    const changes = ["fill", "opacity", "stroke", "strokeWidth", "curve", "missing"];
     if (!changes.some(key => Object.hasOwn(args, key))) {
       throw new Error(
         "editAreaMark requires fill, opacity, stroke, strokeWidth, or curve."
@@ -244,6 +250,7 @@ const editAreaMark = action(
     let config = { ...this.markConfigs[layer.id] };
     if (Object.hasOwn(args, "fill")) {
       config.fill = validateNonEmptyString(args.fill, "Area fill");
+      if (config.errorBand !== undefined) config.errorBand = { ...config.errorBand, fill: config.fill };
     }
     if (Object.hasOwn(args, "opacity")) {
       config.opacity = validateUnitInterval(args.opacity, "Area opacity");
@@ -283,7 +290,14 @@ const editAreaMark = action(
       );
     }
 
-    const next = this._withMarkConfig(layer.id, config);
+    let next = this._withMarkConfig(layer.id, config);
+    if (Object.hasOwn(args, "missing")) {
+      const missing = validateAreaMissing(args.missing);
+      if (missing === "break" && ["density", "horizon"].some(type => findUpstreamTransform(this, findDataset(this, layer.data), type))) {
+        throw new Error("Area missing:break does not reinterpret density or horizon data.");
+      }
+      next = next.editSemantic({ property: `layer[${layer.id}].mark.missing`, value: missing });
+    }
     return canMaterializeArea(next, layer)
       ? next.rematerializeAreaMark({ id: layer.id })
       : next;

package/src/actions/marks/area/materialize.js

@@ -14,6 +14,7 @@ import { buildLinearPathCommands } from
   "../../../grammar/pathCommands.js";
 import { buildCategoricalDensityPaths } from
   "../../../grammar/categoricalDensity.js";
+import { derivePathSeriesFieldValues } from "../../../grammar/pathSeries.js";
 
 function resolveAreaPaths({
   derived,
@@ -135,7 +136,7 @@ export function resolveAreaMaterialization({
       : deriveAreaSeries(rows, layer)
     : deriveDensityAreaSeries(rows, layer, densityTransform);
   const colorEncoding = layer.encoding?.color;
-  const layout = colorEncoding?.layout ?? "overlay";
+  const layout = layer.layout?.mode ?? colorEncoding?.layout ?? "overlay";
   const categoricalDensity = densityTransform?.placement?.type === "category";
   const derived = densityTransform === undefined || categoricalDensity
     ? rawDerived
@@ -164,7 +165,9 @@ export function resolveAreaMaterialization({
     : colorEncoding?.scale === undefined
       ? paths.map(() => config.fill)
       : mapOrdinalValues(
-          derived.series.map(series => series.key[colorEncoding.field]),
+          densityTransform !== undefined || centered
+            ? derived.series.map(series => series.key[colorEncoding.field])
+            : derivePathSeriesFieldValues(rows, derived.series, colorEncoding.field, "color"),
           resolvedScales[colorEncoding.scale].domain,
           resolvedScales[colorEncoding.scale].range
         );

package/src/actions/marks/bar/materialize.js

@@ -10,6 +10,8 @@ import {
   resolveBarOffsetChannel
 } from "../../../grammar/bars/policy.js";
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
+import { offsetCategoryRectangles } from
+  "../../../materialization/categorySlotOffset.js";
 
 const REMATERIALIZE_OPTIONS = Object.freeze(["id", "scales"]);
 
@@ -103,22 +105,24 @@ export const rematerializeBarMark = action(
         resolved = resolved.rematerializeScale({ id: offsetScaleId });
       }
       const width = resolved.markConfigs[id]?.barWidth;
-      return editRectangles(
-        resolved,
-        id,
-        deriveAggregateRectangles(required, resolved, width)
-      );
+      return editRectangles(resolved, id, offsetCategoryRectangles(
+        resolved, required.layer, deriveAggregateRectangles(required, resolved, width)
+      ));
     }
 
     if (required.materialization === BAR_GRAINS.ranged) {
       const width = resolved.markConfigs[id]?.barWidth;
-      return editRectangles(resolved, id, deriveRangedRectangles(required, resolved, width));
+      return editRectangles(resolved, id, offsetCategoryRectangles(
+        resolved, required.layer, deriveRangedRectangles(required, resolved, width)
+      ));
     }
 
     return editRectangles(
       resolved,
       id,
-      deriveHistogramRectangles(required, resolved)
+      offsetCategoryRectangles(
+        resolved, required.layer, deriveHistogramRectangles(required, resolved)
+      )
     );
   }
 );

package/src/actions/marks/index.js

@@ -1,4 +1,5 @@
 import { removeMark } from "./remove.js";
+import { createReferenceLine, createReferenceBand } from "./references.js";
 import { registerRuleMarkActions } from "./rule/index.js";
 import { registerAreaMarkActions } from "./area/index.js";
 import { registerTickMarkActions } from "./tick/index.js";
@@ -8,6 +9,7 @@ import { registerArcMarkActions } from "./arc/index.js";
 import { registerRectMarkActions } from "./rect/index.js";
 import {
   registerPointJitterActions,
+  registerPointPackingActions,
   registerPointMarkActions
 } from "./point/index.js";
 import { registerTextMarkActions } from "./text/index.js";
@@ -15,6 +17,7 @@ import { registerTextMarkActions } from "./text/index.js";
 export function registerMarkActions(ProgramClass) {
   registerPointMarkActions(ProgramClass);
   registerPointJitterActions(ProgramClass);
+  registerPointPackingActions(ProgramClass);
   registerRectMarkActions(ProgramClass);
   registerAreaMarkActions(ProgramClass);
   registerArcMarkActions(ProgramClass);
@@ -24,4 +27,6 @@ export function registerMarkActions(ProgramClass) {
   registerTextMarkActions(ProgramClass);
   registerTickMarkActions(ProgramClass);
   ProgramClass.prototype.removeMark = removeMark;
+  ProgramClass.prototype.createReferenceLine = createReferenceLine;
+  ProgramClass.prototype.createReferenceBand = createReferenceBand;
 }

package/src/actions/marks/line/actions.js

@@ -71,14 +71,14 @@ function validatePolarLineConfig(layer, config) {
   }
 }
 
-function applyLineMaterialization(program, id, materialization, opacity) {
+function applyLineMaterialization(program, id, materialization) {
   return editMarkGraphic(program, id, {
     length: materialization.commands.length,
     commands: materialization.commands,
     stroke: materialization.strokes,
     strokeWidth: materialization.strokeWidths,
     strokeDash: materialization.strokeDashes,
-    ...(opacity === undefined ? {} : { opacity })
+    ...(materialization.opacities === undefined ? {} : { opacity: materialization.opacities })
   });
 }
 
@@ -205,71 +205,34 @@ const rematerializeLineMark = action(
 
     if (parallel !== undefined) {
       validateParallelRows(dataset.values, parallel.dimensions, parallel);
-      let resolved = this;
-      if (args.scales !== false) {
-        for (const dimension of parallel.dimensions) {
-          resolved = resolved.rematerializeScale({ id: dimension.scale });
-        }
-      }
-      for (const channel of args.scales === false
-        ? []
-        : ["color", "strokeDash", "strokeWidth"]) {
-        const scaleId = layer.encoding?.[channel]?.scale;
-        if (scaleId !== undefined) {
-          resolved = resolved.rematerializeScale({ id: scaleId });
-        }
-      }
-      const materialization = resolveParallelLineMaterialization({
-        rows: dataset.values,
-        parallel,
-        layer,
-        resolvedScales: resolved.resolvedScales,
-        bounds: resolveGraphicBounds(resolved),
-        config,
-        existingChildren,
-        defaults: { stroke: DEFAULT_LINE_STROKE, strokeWidth: DEFAULT_LINE_WIDTH }
-      });
-      return applyLineMaterialization(
-        resolved,
-        id,
-        materialization,
-        config.opacity
-      );
     }
-
-    if (
-      polar
-        ? thetaScaleId === undefined || radiusScaleId === undefined
-        : xScaleId === undefined || yScaleId === undefined
-    ) {
-      throw new Error(
-        polar
-          ? `Line mark "${id}" requires theta and radius scales.`
-          : `Line mark "${id}" requires x and y scales.`
-      );
+    const positions = parallel !== undefined
+      ? parallel.dimensions.map(dimension => dimension.scale)
+      : polar ? [thetaScaleId, radiusScaleId] : [xScaleId, yScaleId];
+    if (positions.some(scale => scale === undefined)) {
+      throw new Error(`Line mark "${id}" requires ${polar ? "theta and radius" : "x and y"} scales.`);
     }
-
-    let resolved = args.scales === false
-      ? this
-      : polar
-        ? this
-            .rematerializeScale({ id: thetaScaleId })
-            .rematerializeScale({ id: radiusScaleId })
-        : this
-            .rematerializeScale({ id: xScaleId })
-            .rematerializeScale({ id: yScaleId });
-
-    for (const channel of args.scales === false ? [] : ["color", "strokeDash", "strokeWidth"]) {
-      const scaleId = layer.encoding?.[channel]?.scale;
-      if (scaleId !== undefined) {
-        resolved = resolved.rematerializeScale({ id: scaleId });
+    let resolved = this;
+    if (args.scales !== false) {
+      const appearance = ["color", "strokeDash", "strokeWidth", "opacity"]
+        .map(channel => layer.encoding?.[channel]?.scale).filter(scale => scale !== undefined);
+      for (const scale of [...positions, ...appearance]) {
+        resolved = resolved.rematerializeScale({ id: scale });
       }
     }
+    const shared = {
+      rows: dataset.values, layer, config, existingChildren,
+      resolvedScales: resolved.resolvedScales,
+      bounds: resolveGraphicBounds(resolved),
+      defaults: { stroke: DEFAULT_LINE_STROKE, strokeWidth: DEFAULT_LINE_WIDTH }
+    };
+    if (parallel !== undefined) {
+      return applyLineMaterialization(resolved, id,
+        resolveParallelLineMaterialization({ ...shared, parallel }));
+    }
 
     const materialization = resolvePositionedLineMaterialization({
-      rows: dataset.values,
-      layer,
-      resolvedScales: resolved.resolvedScales,
+      ...shared,
       xBinBoundaries: layer.encoding?.x?.bin === undefined
         ? undefined
         : resolveLineBins(
@@ -277,18 +240,13 @@ const rematerializeLineMark = action(
             layer,
             requireSemanticScale(resolved, xScaleId)
           ).boundaries,
-      bounds: resolveGraphicBounds(resolved),
-      config,
-      existingChildren,
-      polar,
-      defaults: { stroke: DEFAULT_LINE_STROKE, strokeWidth: DEFAULT_LINE_WIDTH }
+      polar
     });
 
     return applyLineMaterialization(
       resolved,
       id,
-      materialization,
-      config.opacity
+      materialization
     );
   }
 );
@@ -300,16 +258,8 @@ const editLineMark = action(
   },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editLineMark");
-    if (
-      !Object.hasOwn(args, "stroke") &&
-      !Object.hasOwn(args, "strokeWidth") &&
-      !Object.hasOwn(args, "opacity") &&
-      !Object.hasOwn(args, "curve") &&
-      !Object.hasOwn(args, "closed")
-    ) {
-      throw new Error(
-        "editLineMark requires stroke, strokeWidth, opacity, curve, or closed."
-      );
+    if (!EDIT_OPTIONS.slice(1).some(key => Object.hasOwn(args, key))) {
+      throw new Error("editLineMark requires stroke, strokeWidth, opacity, curve, or closed.");
     }
     const target = Object.hasOwn(args, "target")
       ? validateUserId(args.target, "Line mark id")
@@ -324,41 +274,26 @@ const editLineMark = action(
         "editLineMark stroke cannot be combined with a color encoding."
       );
     }
+    for (const channel of ["strokeWidth", "opacity"]) {
+      if (Object.hasOwn(args, channel) && layer.encoding?.[channel]?.field !== undefined) {
+        throw new Error(`editLineMark ${channel} conflicts with a field encoding; use its encoder with value to replace it.`);
+      }
+    }
     if (Object.hasOwn(args, "closed") && args.closed === true &&
         (layer.encoding?.x !== undefined || isParallelLine(layer))) {
       throw new Error("Line closed requires theta/radius Polar position encodings.");
     }
-    if (Object.hasOwn(args, "curve") && isPolarLine(layer) &&
-        args.curve !== "linear") {
-      throw new Error("Polar line position currently requires curve \"linear\".");
+    const config = { ...this.markConfigs[layer.id] };
+    for (const [key, validate] of Object.entries({
+      stroke: validateNonEmptyString,
+      strokeWidth: validateNonNegativeFinite,
+      opacity: validateUnitInterval,
+      curve: validateCurveInterpolation,
+      closed: validateClosed
+    })) {
+      if (Object.hasOwn(args, key)) config[key] = validate(args[key], `Line ${key}`);
     }
-    if (Object.hasOwn(args, "curve") && isParallelLine(layer) &&
-        args.curve !== "linear") {
-      throw new Error("Parallel lines require curve \"linear\".");
-    }
-    const config = {
-      ...this.markConfigs[layer.id],
-      ...(Object.hasOwn(args, "stroke")
-        ? { stroke: validateNonEmptyString(args.stroke, "Line stroke") }
-        : {}),
-      ...(Object.hasOwn(args, "strokeWidth")
-        ? {
-            strokeWidth: validateNonNegativeFinite(
-              args.strokeWidth,
-              "Line strokeWidth"
-            )
-          }
-        : {}),
-      ...(Object.hasOwn(args, "opacity")
-        ? { opacity: validateUnitInterval(args.opacity, "Line opacity") }
-        : {}),
-      ...(Object.hasOwn(args, "curve")
-        ? { curve: validateCurveInterpolation(args.curve) }
-        : {}),
-      ...(Object.hasOwn(args, "closed")
-        ? { closed: validateClosed(args.closed) }
-        : {})
-    };
+    validatePolarLineConfig(layer, config);
     const next = this._withMarkConfig(layer.id, config);
     return canMaterializeLine(next, layer)
       ? next.rematerializeLineMark({ id: layer.id })

package/src/actions/marks/line/materialize.js

@@ -1,10 +1,8 @@
 import {
-  deriveLineSeries,
-  deriveLineSeriesFieldValues
+  deriveLineSeries
 } from "../../../grammar/lineSeries.js";
 import {
   mapContinuousScaleValues,
-  mapOrdinalValues,
   normalizeStrokeDashPattern
 } from "../../../grammar/scales/index.js";
 import { buildCurvePathCommands } from
@@ -12,6 +10,7 @@ import { buildCurvePathCommands } from
 import { buildPolarLinePathCommands } from
   "../../../grammar/polarLineCommands.js";
 import { resolvePolarFrame } from "../../../grammar/polar.js";
+import { derivePathSeriesFieldValues } from "../../../grammar/pathSeries.js";
 import { materializeParallelRows } from
   "../../../grammar/parallelCoordinates.js";
 import { mapScaleConsumerValues } from
@@ -21,6 +20,17 @@ function existingValue(children, index, property, fallback) {
   return children[index]?.properties[property] ?? fallback;
 }
 
+function appearanceMapper(layer, scales, fieldValues) {
+  return (channel, fallback) => {
+    const encoding = layer.encoding?.[channel];
+    if (encoding?.datum !== undefined) {
+      return fallback.map(() => normalizeStrokeDashPattern(encoding.datum));
+    }
+    if (encoding?.scale === undefined) return fallback;
+    return mapScaleConsumerValues(fieldValues(encoding.field, channel), scales[encoding.scale], channel);
+  };
+}
+
 export function resolveParallelLineMaterialization({
   rows,
   parallel,
@@ -39,36 +49,25 @@ export function resolveParallelLineMaterialization({
     parallel
   );
   const sourceRows = items.map(item => rows[item.sourceRowIndex]);
-  const mapAppearance = (channel, fallback) => {
-    const encoding = layer.encoding?.[channel];
-    if (encoding?.datum !== undefined) {
-      return items.map(() => channel === "strokeDash"
-        ? normalizeStrokeDashPattern(encoding.datum)
-        : encoding.datum);
-    }
-    if (encoding?.scale === undefined) return items.map(fallback);
-    return mapScaleConsumerValues(
-      sourceRows.map(row => row[encoding.field]),
-      resolvedScales[encoding.scale],
-      channel
-    );
-  };
+  const mapAppearance = appearanceMapper(layer, resolvedScales,
+    field => sourceRows.map(row => row[field]));
   return {
     commands: items.map(item => item.commands),
     strokes: mapAppearance(
       "color",
-      (_, index) => config.stroke ??
-        existingValue(existingChildren, index, "stroke", defaults.stroke)
+      items.map((_, index) => config.stroke ??
+        existingValue(existingChildren, index, "stroke", defaults.stroke))
     ),
     strokeWidths: mapAppearance(
       "strokeWidth",
-      (_, index) => config.strokeWidth ??
-        existingValue(existingChildren, index, "strokeWidth", defaults.strokeWidth)
+      items.map((_, index) => config.strokeWidth ??
+        existingValue(existingChildren, index, "strokeWidth", defaults.strokeWidth))
     ),
     strokeDashes: mapAppearance(
       "strokeDash",
-      (_, index) => existingValue(existingChildren, index, "strokeDash", [])
-    )
+      items.map((_, index) => existingValue(existingChildren, index, "strokeDash", []))
+    ),
+    opacities: mapAppearance("opacity", config.opacity)
   };
 }
 
@@ -116,33 +115,16 @@ export function resolvePositionedLineMaterialization({
           config.curve ?? "linear"
         );
       });
-  const colorEncoding = layer.encoding?.color;
-  const dashEncoding = layer.encoding?.strokeDash;
-  const widthEncoding = layer.encoding?.strokeWidth;
-  const strokes = colorEncoding?.scale === undefined
-    ? commands.map((_, index) => config.stroke ??
-        existingValue(existingChildren, index, "stroke", defaults.stroke))
-    : mapOrdinalValues(
-        derived.series.map(series => series.key[colorEncoding.field]),
-        resolvedScales[colorEncoding.scale].domain,
-        resolvedScales[colorEncoding.scale].range
-      );
-  const strokeWidths = widthEncoding?.scale === undefined
-    ? commands.map((_, index) => config.strokeWidth ??
-        existingValue(existingChildren, index, "strokeWidth", defaults.strokeWidth))
-    : mapContinuousScaleValues(
-        deriveLineSeriesFieldValues(rows, layer, derived, widthEncoding.field),
-        resolvedScales[widthEncoding.scale]
-      );
-  const strokeDashes = dashEncoding?.datum !== undefined
-    ? commands.map(() => normalizeStrokeDashPattern(dashEncoding.datum))
-    : dashEncoding?.scale === undefined
-      ? commands.map((_, index) =>
-          existingValue(existingChildren, index, "strokeDash", []))
-      : mapOrdinalValues(
-          derived.series.map(series => series.key[dashEncoding.field]),
-          resolvedScales[dashEncoding.scale].domain,
-          resolvedScales[dashEncoding.scale].range
-        );
-  return { commands, strokes, strokeWidths, strokeDashes };
+  const appearance = appearanceMapper(layer, resolvedScales,
+    (field, channel) => derivePathSeriesFieldValues(rows, derived.series, field, channel));
+  return {
+    commands,
+    strokes: appearance("color", commands.map((_, index) => config.stroke ??
+      existingValue(existingChildren, index, "stroke", defaults.stroke))),
+    strokeWidths: appearance("strokeWidth", commands.map((_, index) => config.strokeWidth ??
+      existingValue(existingChildren, index, "strokeWidth", defaults.strokeWidth))),
+    strokeDashes: appearance("strokeDash", commands.map((_, index) =>
+      existingValue(existingChildren, index, "strokeDash", []))),
+    opacities: appearance("opacity", config.opacity)
+  };
 }

package/src/actions/marks/point/edit.js

@@ -6,7 +6,7 @@ import {
   validateUnitInterval
 } from "../../../core/validation.js";
 import { validatePointShape } from "../../../grammar/pointShapes.js";
-import { findLayer } from "../../../selectors/layers.js";
+import { resolveEligibleLayer } from "../../../selectors/layers.js";
 import { rematerializeExistingLegend } from "../../encodings/shared.js";
 import { validateMarkOptions } from "../shared.js";
 
@@ -27,20 +27,13 @@ export const editPointMark = action(
         "editPointMark requires shape, fill, opacity, stroke, or strokeWidth."
       );
     }
-    const candidates = this.semanticSpec.layers.filter(
-      layer => layer.mark?.type === "point"
-    );
-    const current = findLayer(this, this.context.currentMark);
-    const requested = args.target ??
-      (current?.mark?.type === "point" ? current.id : undefined);
-    const inferred = requested ?? (candidates.length === 1
-      ? candidates[0].id
-      : undefined);
-    const id = validateUserId(inferred, "Point mark id");
-    const layer = findLayer(this, id);
-    if (layer?.mark?.type !== "point") {
-      throw new Error(`Unknown point mark "${id}".`);
-    }
+    if (args.target !== undefined) validateUserId(args.target, "Point mark id");
+    const layer = resolveEligibleLayer(this, {
+      target: args.target,
+      predicate: candidate => candidate.mark?.type === "point",
+      label: "point mark"
+    });
+    const id = layer.id;
     if (Object.hasOwn(args, "shape") && layer.encoding?.shape !== undefined) {
       throw new Error(
         "editPointMark shape cannot be combined with a shape encoding."
@@ -51,6 +44,9 @@ export const editPointMark = action(
         "editPointMark fill cannot be combined with a color encoding."
       );
     }
+    if (Object.hasOwn(args, "opacity") && layer.encoding?.opacity?.field !== undefined) {
+      throw new Error("editPointMark opacity conflicts with a field encoding; use encodeOpacity with value to replace it.");
+    }
     const config = { ...this.markConfigs[id] };
     if (Object.hasOwn(args, "shape")) {
       config.shape = validatePointShape(args.shape);

package/src/actions/marks/point/index.js

@@ -3,6 +3,7 @@ import { editPointMark } from "./edit.js";
 import { rematerializePointMark } from "./materialize.js";
 
 export { registerPointJitterActions } from "./jitter.js";
+export { registerPointPackingActions } from "./packing.js";
 
 export function registerPointMarkActions(ProgramClass) {
   ProgramClass.prototype.editPointMark = editPointMark;

package/src/actions/marks/point/jitter.js

@@ -37,6 +37,9 @@ export const jitterPoints = action(
     validateKeys(args, JITTER_OPTIONS, "jitterPoints");
     const policy = normalizePointJitterPolicy(args);
     const layer = resolveJitterTarget(this, args.target, policy.channel);
+    if (this.materializationConfigs.pointPacking?.[layer.id] !== undefined) {
+      throw new Error(`Point jitter on "${layer.id}" conflicts with point packing.`);
+    }
     return this
       ._withMaterializationConfig(["jitters", layer.id], policy)
       .rematerializePointMark({ id: layer.id });