ggaction 0.0.12 → 0.0.15

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

@@ -19,7 +19,11 @@ import { DEFAULT_COLORS } from "../../../theme/defaults.js";
 import { findDataset } from "../../../selectors/datasets.js";
 import { findLayer, resolveEligibleLayer } from "../../../selectors/layers.js";
 import { validateCurveInterpolation } from "../../../grammar/curveCommands.js";
-import { resolveGraphicBounds } from "../../../layout/canvas.js";
+import {
+  resolveCoordinateBounds,
+  resolveCoordinatePolarFrame
+} from "../../../materialization/coordinateBounds.js";
+import { rematerializeExistingLegend } from "../../encodings/shared.js";
 import { canMaterializeLine } from "../../../materialization/marks/index.js";
 import { resolveMarkGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
@@ -31,14 +35,20 @@ import {
 } from "./materialize.js";
 import { resolveLineBins } from "../../../grammar/lineSeries.js";
 import { requireSemanticScale } from "../../../selectors/scales.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../../grammar/strokeStyle.js";
 
 const DEFAULT_LINE_STROKE = DEFAULT_COLORS.mark;
 const DEFAULT_LINE_WIDTH = 2;
 const CREATE_OPTIONS = Object.freeze([
-  "id", "data", "stroke", "strokeWidth", "opacity", "curve", "closed"
+  "id", "data", "stroke", "strokeWidth", "opacity", "curve", "closed",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 const EDIT_OPTIONS = Object.freeze([
-  "target", "stroke", "strokeWidth", "opacity", "curve", "closed"
+  "target", "stroke", "strokeWidth", "opacity", "curve", "closed",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id", "scales"]);
 
@@ -71,14 +81,15 @@ function validatePolarLineConfig(layer, config) {
   }
 }
 
-function applyLineMaterialization(program, id, materialization, opacity) {
+function applyLineMaterialization(program, id, materialization, config) {
   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 }),
+    ...requestedStrokeDetails(config, "Line mark")
   });
 }
 
@@ -89,6 +100,7 @@ const createLineMark = action(
   },
   function (args = {}) {
     validateMarkOptions(args, CREATE_OPTIONS, "createLineMark");
+    const strokeDetails = requestedStrokeDetails(args, "createLineMark");
     const id = resolveMarkId(this, args.id, {
       defaultId: "line",
       label: "Line mark id",
@@ -139,7 +151,8 @@ const createLineMark = action(
         {
           ...(Object.hasOwn(args, "strokeWidth") ? { strokeWidth } : {}),
           ...(Object.hasOwn(args, "curve") ? { curve } : {}),
-          ...(Object.hasOwn(args, "closed") ? { closed } : {})
+          ...(Object.hasOwn(args, "closed") ? { closed } : {}),
+          ...strokeDetails
         }
       );
     created = materializeInheritedMark(created, id);
@@ -205,71 +218,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", "stroke", "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: resolveCoordinateBounds(resolved, layer.coordinate),
+      defaults: { stroke: DEFAULT_LINE_STROKE, strokeWidth: DEFAULT_LINE_WIDTH }
+    };
+    if (parallel !== undefined) {
+      return applyLineMaterialization(resolved, id,
+        resolveParallelLineMaterialization({ ...shared, parallel }), config);
+    }
 
     const materialization = resolvePositionedLineMaterialization({
-      rows: dataset.values,
-      layer,
-      resolvedScales: resolved.resolvedScales,
+      ...shared,
       xBinBoundaries: layer.encoding?.x?.bin === undefined
         ? undefined
         : resolveLineBins(
@@ -277,18 +253,17 @@ const rematerializeLineMark = action(
             layer,
             requireSemanticScale(resolved, xScaleId)
           ).boundaries,
-      bounds: resolveGraphicBounds(resolved),
-      config,
-      existingChildren,
       polar,
-      defaults: { stroke: DEFAULT_LINE_STROKE, strokeWidth: DEFAULT_LINE_WIDTH }
+      ...(polar
+        ? { polarFrame: resolveCoordinatePolarFrame(resolved, layer.coordinate) }
+        : {})
     });
 
     return applyLineMaterialization(
       resolved,
       id,
       materialization,
-      config.opacity
+      config
     );
   }
 );
@@ -300,16 +275,9 @@ 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."
-      );
+    const strokeDetails = requestedStrokeDetails(args, "editLineMark");
+    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")
@@ -319,50 +287,40 @@ const editLineMark = action(
       predicate: candidate => candidate.mark?.type === "line",
       label: "line mark"
     });
-    if (Object.hasOwn(args, "stroke") && layer.encoding?.color !== undefined) {
+    if (Object.hasOwn(args, "stroke") && (
+      layer.encoding?.color !== undefined ||
+      layer.encoding?.stroke !== undefined
+    )) {
       throw new Error(
-        "editLineMark stroke cannot be combined with a color encoding."
+        "editLineMark stroke cannot be combined with a color encoding or a stroke encoding; use encodeStroke with value to replace it."
       );
     }
+    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\".");
-    }
-    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.assign(config, strokeDetails);
+    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}`);
     }
-    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)
+    const materialized = canMaterializeLine(next, layer)
       ? next.rematerializeLineMark({ id: layer.id })
       : next;
+    return rematerializeExistingLegend(materialized);
   }
 );
 

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,21 @@ 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, encoding),
+      scales[encoding.scale],
+      channel
+    );
+  };
+}
+
 export function resolveParallelLineMaterialization({
   rows,
   parallel,
@@ -39,36 +53,29 @@ 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)
-    ),
+    strokes: layer.encoding?.stroke?.scale !== undefined
+      ? mapAppearance("stroke", items.map(() => defaults.stroke))
+      : config.stroke !== undefined
+        ? items.map(() => config.stroke)
+        : mapAppearance(
+            "color",
+            items.map((_, index) =>
+              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)
   };
 }
 
@@ -81,6 +88,7 @@ export function resolvePositionedLineMaterialization({
   config,
   existingChildren,
   polar,
+  polarFrame,
   defaults
 }) {
   const xScaleId = layer.encoding?.x?.scale;
@@ -99,7 +107,7 @@ export function resolvePositionedLineMaterialization({
         thetaFieldType: derived.thetaFieldType,
         thetaScale: resolvedScales[thetaScaleId],
         radiusScale: resolvedScales[radiusScaleId],
-        frame: resolvePolarFrame(bounds),
+        frame: polarFrame ?? resolvePolarFrame(bounds),
         closed: config.closed ?? false
       }))
     : derived.series.map(series => {
@@ -116,33 +124,26 @@ 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, encoding) => derivePathSeriesFieldValues(
+      rows,
+      derived.series,
+      field,
+      channel,
+      encoding
+    ));
+  return {
+    commands,
+    strokes: layer.encoding?.stroke?.scale !== undefined
+      ? appearance("stroke", commands.map(() => defaults.stroke))
+      : config.stroke !== undefined
+        ? commands.map(() => config.stroke)
+        : appearance("color", commands.map((_, index) =>
+            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/create.js

@@ -1,6 +1,10 @@
 import { action } from "../../../core/action.js";
 import { validatePointShape } from "../../../grammar/pointShapes.js";
 import { getPointGraphicType } from "../../../grammar/schemas/mark.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../../grammar/strokeStyle.js";
 import { resolveMarkGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
 import {
@@ -14,7 +18,8 @@ import {
 } from "../shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "data", "shape", "fill", "opacity", "stroke", "strokeWidth"
+  "id", "data", "shape", "fill", "opacity", "stroke", "strokeWidth",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 
 export const createPointMark = action(
@@ -24,6 +29,7 @@ export const createPointMark = action(
   },
   function (args = {}) {
     validateMarkOptions(args, OPTIONS, "createPointMark");
+    requestedStrokeDetails(args, "createPointMark");
     const id = resolveMarkId(this, args.id, {
       defaultId: "point",
       label: "Point mark id",
@@ -65,7 +71,7 @@ export const createPointMark = action(
       ._withMarkConfig(id, { shape });
     const created = materializeInheritedMark(next, id);
     const appearance = Object.fromEntries(
-      ["fill", "opacity", "stroke", "strokeWidth"]
+      ["fill", "opacity", "stroke", "strokeWidth", ...STROKE_STYLE_PROPERTIES]
         .filter(property => Object.hasOwn(args, property))
         .map(property => [property, args[property]])
     );

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

@@ -6,12 +6,17 @@ import {
   validateUnitInterval
 } from "../../../core/validation.js";
 import { validatePointShape } from "../../../grammar/pointShapes.js";
-import { findLayer } from "../../../selectors/layers.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../../grammar/strokeStyle.js";
+import { resolveEligibleLayer } from "../../../selectors/layers.js";
 import { rematerializeExistingLegend } from "../../encodings/shared.js";
 import { validateMarkOptions } from "../shared.js";
 
 const OPTIONS = Object.freeze([
-  "target", "shape", "fill", "opacity", "stroke", "strokeWidth"
+  "target", "shape", "fill", "opacity", "stroke", "strokeWidth",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 
 export const editPointMark = action(
@@ -21,26 +26,23 @@ export const editPointMark = action(
   },
   function (args = {}) {
     validateMarkOptions(args, OPTIONS, "editPointMark");
-    const editable = ["shape", "fill", "opacity", "stroke", "strokeWidth"];
+    const strokeDetails = requestedStrokeDetails(args, "editPointMark");
+    const editable = [
+      "shape", "fill", "opacity", "stroke", "strokeWidth",
+      ...STROKE_STYLE_PROPERTIES
+    ];
     if (!editable.some(property => Object.hasOwn(args, property))) {
       throw new Error(
         "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,7 +53,16 @@ export const editPointMark = action(
         "editPointMark fill cannot be combined with a color encoding."
       );
     }
+    if (Object.hasOwn(args, "stroke") && layer.encoding?.stroke !== undefined) {
+      throw new Error(
+        "editPointMark stroke conflicts with a field encoding; use encodeStroke with value to replace it."
+      );
+    }
+    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] };
+    Object.assign(config, strokeDetails);
     if (Object.hasOwn(args, "shape")) {
       config.shape = validatePointShape(args.shape);
     }
@@ -89,9 +100,6 @@ export const editPointMark = action(
     const next = this
       ._withMarkConfig(id, config)
       .rematerializePointMark({ id });
-    const legend = next.guideConfigs.legend?.series;
-    return legend?.target === id && legend.channels.includes("shape")
-      ? rematerializeExistingLegend(next)
-      : next;
+    return rematerializeExistingLegend(next);
   }
 );

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 });