ggaction 0.0.11 → 0.0.13

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

@@ -11,6 +11,10 @@ import {
   normalizePointJitterPolicy,
   resolvePointJitter
 } from "../../../grammar/jitter.js";
+import {
+  normalizePointPackingPolicy,
+  resolvePointPacking
+} from "../../../grammar/pointPacking.js";
 import { polarToCartesian, resolvePolarFrame } from "../../../grammar/polar.js";
 import { resolveDirectionValues } from "../../../grammar/direction.js";
 import { resolveGraphicBounds } from "../../../layout/canvas.js";
@@ -21,9 +25,15 @@ import {
 } from "../../../theme/defaults.js";
 import { findDataset } from "../../../selectors/datasets.js";
 import { findLayer } from "../../../selectors/layers.js";
+import { canMaterializePoint } from "../../../materialization/marks/capabilities.js";
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
-import { resolveRowEncodingValues } from
+import {
+  resolveRowEncodingValues,
+  resolveRowPositionValues
+} from
   "../../../materialization/rowEncoding.js";
+import { offsetCategoryPositions } from
+  "../../../materialization/categorySlotOffset.js";
 
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
 const DEFAULT_POINT_FILL = DEFAULT_COLORS.mark;
@@ -33,8 +43,8 @@ function resolvePointPositions(program, layer, dataset) {
     layer.encoding?.radius !== undefined;
   if (!hasPolar) {
     return {
-      x: resolveRowEncodingValues(program, layer, dataset, "x"),
-      y: resolveRowEncodingValues(program, layer, dataset, "y")
+      x: resolveRowPositionValues(program, layer, dataset, "x"),
+      y: resolveRowPositionValues(program, layer, dataset, "y")
     };
   }
   const theta = resolveRowEncodingValues(program, layer, dataset, "theta");
@@ -207,6 +217,80 @@ function applyPointJitter(program, {
   };
 }
 
+function applyPointPacking(program, {
+  id,
+  layer,
+  dataset,
+  x,
+  y,
+  area,
+  shapes,
+  angles,
+  config,
+  graphic,
+  existingChildren
+}) {
+  const stored = program.materializationConfigs.pointPacking?.[id];
+  if (stored === undefined) return { program, x, y };
+  const policy = normalizePointPackingPolicy(stored);
+  const encoding = layer.encoding?.[policy.channel];
+  const scale = program.resolvedScales[encoding?.scale];
+  if (scale === undefined) {
+    throw new Error(`Point packing on "${id}" requires a resolved ${policy.channel} scale.`);
+  }
+  const seen = new Set();
+  const entries = dataset.values.flatMap((row, index) => {
+    if (!Number.isFinite(x?.[index]) || !Number.isFinite(y?.[index])) return [];
+    const rawIdentity = policy.key === undefined ? index : row[policy.key];
+    const identity = canonicalJitterScalar(
+      rawIdentity,
+      policy.key === undefined
+        ? "Point packing source index"
+        : `Point packing key field "${policy.key}"`
+    );
+    if (seen.has(identity)) {
+      throw new Error(`Point packing key field "${policy.key}" must be unique for materialized items.`);
+    }
+    seen.add(identity);
+    const resolvedArea = resolvedPointArea(
+      area, index, config, existingChildren, graphic.type
+    );
+    const extent = resolvePointShapeExtent({
+      shape: shapes[index],
+      area: resolvedArea,
+      strokeWidth: typeof config.stroke === "string" ? config.strokeWidth ?? 1 : 0,
+      angle: angles?.[index]
+    });
+    return [{
+      index,
+      identity,
+      base: policy.channel === "x" ? x[index] : y[index],
+      fixed: policy.channel === "x" ? y[index] : x[index],
+      halfExtent: extent[policy.channel],
+      fixedHalfExtent: extent[policy.channel === "x" ? "y" : "x"]
+    }];
+  });
+  const bounds = resolveGraphicBounds(program);
+  const resolution = resolvePointPacking({
+    target: id,
+    policy,
+    scale,
+    entries,
+    plotMinimum: policy.channel === "x" ? bounds.x : bounds.y,
+    plotMaximum: policy.channel === "x" ? bounds.x + bounds.width : bounds.y + bounds.height
+  });
+  const values = [...(policy.channel === "x" ? x : y)];
+  for (const item of resolution.items) values[item.index] = item.final;
+  return {
+    program: program._withMaterializationConfig(["pointPacking", id], {
+      ...policy,
+      resolved: resolution
+    }),
+    x: policy.channel === "x" ? values : x,
+    y: policy.channel === "y" ? values : y
+  };
+}
+
 export const rematerializePointMark = action(
   {
     op: "rematerializePointMark",
@@ -222,8 +306,20 @@ export const rematerializePointMark = action(
       resetValue: []
     });
     if (highlighted !== undefined) return highlighted;
-    const layer = findLayer(this, id);
-    const graphic = this.graphicSpec.objects[id];
+    let resolved = this;
+    const initialLayer = findLayer(resolved, id);
+    for (const channel of ["xOffset", "yOffset"]) {
+      const scaleId = initialLayer?.encoding?.[channel]?.scale;
+      if (scaleId !== undefined) {
+        resolved = resolved.rematerializeScale({
+          id: scaleId,
+          guides: false,
+          marks: false
+        });
+      }
+    }
+    const layer = findLayer(resolved, id);
+    const graphic = resolved.graphicSpec.objects[id];
 
     if (layer?.mark?.type !== "point") {
       throw new Error(`Unknown point mark "${id}".`);
@@ -231,18 +327,27 @@ export const rematerializePointMark = action(
     if (!["circle", "rect", "path", "collection"].includes(graphic?.type)) {
       throw new Error(`Point mark "${id}" requires point graphics.`);
     }
-    const dataset = findDataset(this, layer.data);
+    const dataset = findDataset(resolved, layer.data);
     if (dataset === undefined) {
       throw new Error(`Point mark "${id}" requires an existing dataset.`);
     }
 
-    const positions = resolvePointPositions(this, layer, dataset);
-    const mappedFill = resolveRowEncodingValues(this, layer, dataset, "color");
-    const area = resolveRowEncodingValues(this, layer, dataset, "size");
-    const encodedShape = resolveRowEncodingValues(this, layer, dataset, "shape");
-    const encodedOpacity = resolveRowEncodingValues(this, layer, dataset, "opacity");
+    if (graphic.items.length === 0 && !canMaterializePoint(resolved, layer)) {
+      return resolved;
+    }
+
+    const positions = resolvePointPositions(resolved, layer, dataset);
+    const mappedFill = resolveRowEncodingValues(resolved, layer, dataset, "color");
+    const area = resolveRowEncodingValues(resolved, layer, dataset, "size");
+    const encodedShape = resolveRowEncodingValues(resolved, layer, dataset, "shape");
+    const encodedOpacity = resolveRowEncodingValues(
+      resolved,
+      layer,
+      dataset,
+      "opacity"
+    );
     const angles = resolveDirectionValues(dataset.values, layer.encoding?.angle);
-    const config = this.markConfigs[id] ?? {};
+    const config = resolved.markConfigs[id] ?? {};
     const fill = mappedFill ?? config.fill ?? DEFAULT_POINT_FILL;
     const shapes = encodedShape ?? dataset.values.map(() => config.shape ?? "circle");
     const existingChildren = graphic.items ?? [];
@@ -252,7 +357,13 @@ export const rematerializePointMark = action(
       angles !== undefined ||
       graphic.type === "collection" ||
       getPointGraphicType(constantShape) !== graphic.type;
-    const jittered = applyPointJitter(this, {
+    if (
+      resolved.materializationConfigs.jitters?.[id] !== undefined &&
+      resolved.materializationConfigs.pointPacking?.[id] !== undefined
+    ) {
+      throw new Error(`Point mark "${id}" cannot combine jitter and packing.`);
+    }
+    const packed = applyPointPacking(resolved, {
       id,
       layer,
       dataset,
@@ -265,7 +376,20 @@ export const rematerializePointMark = action(
       graphic,
       existingChildren
     });
-    const { x, y } = jittered;
+    const jittered = applyPointJitter(packed.program, {
+      id,
+      layer,
+      dataset,
+      x: packed.x,
+      y: packed.y,
+      area,
+      shapes,
+      angles,
+      config,
+      graphic,
+      existingChildren
+    });
+    const { x, y } = offsetCategoryPositions(jittered.program, layer, jittered);
 
     if (requiresMixedCollection) {
       const items = dataset.values.map((_, index) => {

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

@@ -0,0 +1,68 @@
+import { action } from "../../../core/action.js";
+import { validateUserId } from "../../../core/identifiers.js";
+import { validateKeys } from "../../../core/validation.js";
+import { normalizePointPackingPolicy } from "../../../grammar/pointPacking.js";
+import { findCoordinate } from "../../../selectors/coordinates.js";
+import { resolveEligibleLayer } from "../../../selectors/layers.js";
+
+const OPTIONS = Object.freeze([
+  "target", "channel", "maxOffset", "padding", "key", "overflow"
+]);
+const REMOVE_OPTIONS = Object.freeze(["target"]);
+
+function isPackablePoint(program, layer, channel) {
+  const packed = layer.encoding?.[channel];
+  const fixed = layer.encoding?.[channel === "x" ? "y" : "x"];
+  return layer.mark?.type === "point" &&
+    ["nominal", "ordinal"].includes(packed?.fieldType) &&
+    ["quantitative", "temporal"].includes(fixed?.fieldType) &&
+    packed.scale !== undefined && fixed.scale !== undefined &&
+    findCoordinate(program, layer.coordinate)?.type === "cartesian";
+}
+
+function target(program, requested, channel) {
+  return resolveEligibleLayer(program, {
+    target: requested === undefined ? undefined : validateUserId(requested, "Point packing target"),
+    predicate: layer => isPackablePoint(program, layer, channel),
+    label: "point packing"
+  });
+}
+
+export const packPoints = action(
+  { op: "packPoints", description: "Pack point glyphs deterministically within categorical slots." },
+  function (args = {}) {
+    validateKeys(args, OPTIONS, "packPoints");
+    const policy = normalizePointPackingPolicy(args);
+    const layer = target(this, args.target, policy.channel);
+    if (this.materializationConfigs.jitters?.[layer.id] !== undefined) {
+      throw new Error(`Point packing on "${layer.id}" conflicts with point jitter.`);
+    }
+    return this
+      ._withMaterializationConfig(["pointPacking", layer.id], policy)
+      .rematerializePointMark({ id: layer.id });
+  }
+);
+
+export const removePointPacking = action(
+  { op: "removePointPacking", description: "Remove point packing and restore semantic positions." },
+  function (args = {}) {
+    validateKeys(args, REMOVE_OPTIONS, "removePointPacking");
+    const requested = args.target === undefined
+      ? undefined
+      : validateUserId(args.target, "Point packing target");
+    const layer = resolveEligibleLayer(this, {
+      target: requested,
+      predicate: candidate => candidate.mark?.type === "point" &&
+        this.materializationConfigs.pointPacking?.[candidate.id] !== undefined,
+      label: "point packing"
+    });
+    return this
+      ._withoutMaterializationConfig(["pointPacking", layer.id])
+      .rematerializePointMark({ id: layer.id });
+  }
+);
+
+export function registerPointPackingActions(ProgramClass) {
+  ProgramClass.prototype.packPoints = packPoints;
+  ProgramClass.prototype.removePointPacking = removePointPacking;
+}

package/src/actions/marks/references.js

@@ -0,0 +1,87 @@
+import { isSourceOwnedText } from "../../grammar/text.js";
+import { action } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+import { findCoordinate } from "../../selectors/coordinates.js";
+import { resolveEligibleLayer } from "../../selectors/layers.js";
+import { resolveFacadeData, resolveFacadeId, validateFacadeOptions } from "../charts/shared.js";
+
+const COMMON_OPTIONS = ["id", "x", "y", "space", "source", "data", "coordinate", "temporalUnit"];
+const LINE_STYLE = ["stroke", "strokeWidth", "strokeDash", "opacity"];
+const BAND_STYLE = ["fill", "opacity", "stroke", "strokeWidth"];
+
+function resolveBinding(program, args, axis, operation, band) {
+  const space = args.space === undefined ? "data" : args.space;
+  if (space !== "data" && space !== "plot") {
+    throw new Error(`${operation} space must be data or plot.`);
+  }
+  if (space === "plot") {
+    if (Object.hasOwn(args, "source") || Object.hasOwn(args, "temporalUnit")) {
+      throw new Error(`${operation} plot space does not accept source or temporalUnit.`);
+    }
+    return { data: resolveFacadeData(program, args.data, operation),
+      fieldType: "quantitative", coordinate: args.coordinate, plot: true };
+  }
+  if (Object.hasOwn(args, "data") || Object.hasOwn(args, "coordinate")) {
+    throw new Error(`${operation} data space uses source data and coordinate.`);
+  }
+  const source = resolveEligibleLayer(program, {
+    target: args.source === undefined ? undefined : validateUserId(args.source, `${operation} source`),
+    predicate: layer => !isSourceOwnedText(layer) && layer.data !== undefined && layer.encoding?.[axis]?.scale !== undefined &&
+      findCoordinate(program, layer.coordinate)?.type === "cartesian" &&
+      (!band || ["quantitative", "temporal"].includes(layer.encoding[axis].fieldType)),
+    label: `${operation} Cartesian layer`,
+    targetOption: "source"
+  });
+  const encoding = source.encoding[axis];
+  return { data: source.data, coordinate: source.coordinate, scale: encoding.scale,
+    fieldType: encoding.fieldType, temporalUnit: args.temporalUnit === undefined ? encoding.temporalUnit : args.temporalUnit };
+}
+
+function createReference(program, args, band) {
+  const operation = band ? "createReferenceBand" : "createReferenceLine";
+  const styleOptions = band ? BAND_STYLE : LINE_STYLE;
+  validateFacadeOptions(args, [...COMMON_OPTIONS, ...styleOptions], operation);
+  const axes = ["x", "y"].filter(axis => Object.hasOwn(args, axis));
+  if (axes.length !== 1) throw new Error(`${operation} requires exactly one of x or y.`);
+  const axis = axes[0];
+  const values = band ? args[axis] : [args[axis]];
+  if (!Array.isArray(values) || values.length !== (band ? 2 : 1)) {
+    throw new Error(`${operation} ${axis} requires a two-value interval.`);
+  }
+  const id = resolveFacadeId(program, args.id, {
+    defaultId: band ? "referenceBand" : "referenceLine", operation
+  });
+  const binding = resolveBinding(program, args, axis, operation, band);
+  if (binding.plot && !values.every(value => Number.isFinite(value) && value >= 0 && value <= 1)) {
+    throw new Error(`${operation} plot coordinates must be finite numbers in [0, 1].`);
+  }
+  const scale = binding.plot ? `${id}-${axis}` : binding.scale;
+  const style = Object.fromEntries(styleOptions.filter(key => args[key] !== undefined).map(key => [key, args[key]]));
+  const encode = axis === "x" ? "encodeX" : "encodeY";
+  const options = { target: id, fieldType: binding.fieldType, scale: { id: scale },
+    ...(binding.coordinate === undefined ? {} : { coordinate: binding.coordinate }),
+    ...(binding.temporalUnit === undefined ? {} : { temporalUnit: binding.temporalUnit }) };
+  const apply = initial => {
+    let next = binding.plot
+      ? initial.createScale({ id: scale, type: "linear", domain: [0, 1] })
+      : initial;
+    next = band
+      ? next.createRectMark({ id, data: binding.data, fill: "#94a3b8", opacity: 0.15, stroke: false, ...style })
+      : next.createRuleMark({ id, data: binding.data, stroke: "#64748b", strokeWidth: 1, strokeDash: "dashed", ...style });
+    next = next[encode]({ ...options, datum: values[0] });
+    return band ? next[`${encode}2`]({ ...options, datum: values[1] }) : next;
+  };
+  // Validate the complete lower-action chain on a discarded immutable branch.
+  apply(program);
+  return apply(program);
+}
+
+export const createReferenceLine = action(
+  { op: "createReferenceLine", description: "Create a constant reference line in data or plot coordinates." },
+  function (args = {}) { return createReference(this, args, false); }
+);
+
+export const createReferenceBand = action(
+  { op: "createReferenceBand", description: "Create a constant reference interval in data or plot coordinates." },
+  function (args = {}) { return createReference(this, args, true); }
+);

package/src/actions/marks/remove.js

@@ -1,8 +1,10 @@
+import { isSourceOwnedText } from "../../grammar/text.js";
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateKeys } from "../../core/validation.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { findLayer } from "../../selectors/layers.js";
+import { applyDetachedScaleRematerialization } from "../../materialization/dependencies.js";
 import {
   getPositionChannelDefinition,
   POSITION_CHANNELS
@@ -28,12 +30,17 @@ function ownedChildren(program, id) {
     config.boxPlot?.whiskerId,
     config.boxPlot?.medianId,
     config.boxPlot?.outlierId,
-    config.gradientPlot?.centerId
+    config.gradientPlot?.centerId,
+    config.intervalPlot?.intervalId,
+    config.endpointPlot?.roles?.stemId,
+    config.endpointPlot?.roles?.startId,
+    config.endpointPlot?.roles?.connectorId,
+    ...(config.raincloudPlot?.ownedChildIds ?? [])
   ].concat(
     program.semanticSpec.layers
       .filter(layer => layer.source === id)
       .map(layer => layer.id)
-  ).filter(child => child !== undefined && findLayer(program, child) !== undefined);
+  ).filter(child => child !== undefined && child !== id && findLayer(program, child) !== undefined);
 }
 
 function ownership(program) {
@@ -90,7 +97,10 @@ function ownedDerivedData(program, ids) {
       config.regression?.dataId,
       config.boxPlot?.summaryId,
       config.boxPlot?.outlierDataId,
-      config.gradientPlot?.profileId
+      config.gradientPlot?.profileId,
+      config.violinPlot?.materialized === true ? layer?.data : undefined,
+      config.ecdfPlot?.data,
+      config.endpointPlot?.data
     ]) {
       if (candidate !== undefined) candidates.add(candidate);
     }
@@ -161,7 +171,7 @@ export function removeOwnedMark(program, id, partial = false) {
 
 function hasScaleConsumer(program, channel, scale) {
   return program.semanticSpec.layers.some(
-    layer => layer.encoding?.[channel]?.scale === scale
+    layer => !isSourceOwnedText(layer) && layer.encoding?.[channel]?.scale === scale
   );
 }
 
@@ -198,6 +208,7 @@ export const removeMark = action(
     validateKeys(args, OPTIONS, "removeMark");
     const owner = resolveOwner(this, args.target);
     const ids = collectClosure(this, owner.id);
+    const previousLayers = ids.map(id => findLayer(this, id));
     const derived = ownedDerivedData(this, ids);
     const positionScales = usedPositionScales(this, ids);
     let next = this;
@@ -227,6 +238,7 @@ export const removeMark = action(
       }
       next = next._withoutMaterializationConfig(["marks", id]);
       next = next._withoutMaterializationConfig(["jitters", id]);
+      next = next._withoutMaterializationConfig(["pointPacking", id]);
       next = next._withoutMaterializationConfig(["labelLayouts", id]);
     }
 
@@ -236,6 +248,7 @@ export const removeMark = action(
         next = next.releaseDerivedData({ id });
       }
     }
+    next = applyDetachedScaleRematerialization(next, previousLayers);
     return next._withContext({
       ...(ids.includes(this.context.currentMark) ? { currentMark: undefined } : {}),
       ...(selectionCleanup.selectionIds.includes(this.context.currentSelection)

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

@@ -3,6 +3,7 @@ import { validateUserId } from "../../../core/identifiers.js";
 import { validatePositiveFinite } from "../../../core/validation.js";
 import {
   mapContinuousScaleValues,
+  mapOrdinalOffsetValues,
   mapOrdinalPositionValues,
   mapOrdinalValues,
   normalizeStrokeDashPattern
@@ -10,7 +11,8 @@ import {
 import { deriveRuleValues, resolveRuleMode } from "../../../grammar/rules.js";
 import { resolveGraphicBounds } from "../../../layout/canvas.js";
 import { findDataset } from "../../../selectors/datasets.js";
-import { findLayer } from "../../../selectors/layers.js";
+import { findLayer, resolveEligibleLayer } from "../../../selectors/layers.js";
+import { applyRuleAppearance, planRuleAppearance } from "./appearance.js";
 import { DEFAULT_COLORS } from "../../../theme/defaults.js";
 import {
   assertMarkAvailable,
@@ -25,8 +27,13 @@ import {
 import { resolveMarkGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
+import { applyOffsetPositionValues } from
+  "../../../materialization/rowEncoding.js";
+import { resolveCategorySlotOffset } from
+  "../../../materialization/categorySlotOffset.js";
 
-const CREATE_OPTIONS = Object.freeze(["id", "data"]);
+const CREATE_OPTIONS = Object.freeze(["id", "data", "stroke", "strokeWidth", "strokeDash", "opacity"]);
+const EDIT_OPTIONS = Object.freeze(["target", "stroke", "strokeWidth", "strokeDash", "opacity"]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
 const SPAN_OPTIONS = Object.freeze(["id", "orientation", "size"]);
 const DEFAULT_RULE_CONFIG = Object.freeze({
@@ -93,6 +100,7 @@ const createRuleMark = action(
         inherited?.data !== undefined ? { data: inherited.data } : {})
     });
     assertMarkAvailable(this, id);
+    const appearance = planRuleAppearance(args, inherited);
 
     let created = this
       .editSemantic({ property: `layer[${id}].mark.type`, value: "rule" })
@@ -116,7 +124,23 @@ const createRuleMark = action(
               }
             })
       });
-    return materializeInheritedMark(created, id);
+    return applyRuleAppearance(materializeInheritedMark(created, id), id, appearance);
+  }
+);
+
+const editRuleMark = action(
+  { op: "editRuleMark", description: "Edit constant rule appearance through its encoding owners." },
+  function (args = {}) {
+    validateMarkOptions(args, EDIT_OPTIONS, "editRuleMark");
+    if (args.target !== undefined) validateUserId(args.target, "Rule mark id");
+    const layer = resolveEligibleLayer(this, {
+      target: args.target,
+      predicate: candidate => candidate.mark?.type === "rule",
+      label: "rule mark"
+    });
+    const appearance = planRuleAppearance(args, layer);
+    if (appearance.length === 0) throw new Error("editRuleMark requires an appearance change.");
+    return applyRuleAppearance(this, layer.id, appearance);
   }
 );
 
@@ -154,7 +178,10 @@ const rematerializeRuleMark = action(
     }
 
     const scaleIds = [...new Set(
-      ["x", "y", "x2", "y2", "strokeDash", "strokeWidth", "opacity"]
+      [
+        "x", "y", "x2", "y2", "xOffset", "yOffset",
+        "strokeDash", "strokeWidth", "opacity"
+      ]
         .map(channel => layer.encoding?.[channel]?.scale)
         .filter(scale => scale !== undefined)
     )];
@@ -178,6 +205,25 @@ const rematerializeRuleMark = action(
         resolved.resolvedScales[encoding.scale]
       );
     }
+    for (const [channel, offsetChannel] of [
+      ["x", "xOffset"],
+      ["y", "yOffset"]
+    ]) {
+      const encoding = layer.encoding?.[offsetChannel];
+      if (encoding === undefined || mapped[channel] === undefined) continue;
+      const offsetScale = resolved.resolvedScales[encoding.scale];
+      const offset = mapOrdinalOffsetValues(
+        derived.values[offsetChannel],
+        offsetScale
+      );
+      mapped[channel] = applyOffsetPositionValues({
+        base: mapped[channel],
+        offset,
+        parentScale: resolved.resolvedScales[layer.encoding[channel].scale],
+        offsetScale,
+        channel
+      });
+    }
     const bounds = resolveGraphicBounds(resolved);
     const x1 = [];
     const y1 = [];
@@ -238,6 +284,15 @@ const rematerializeRuleMark = action(
       x2.push(endX);
       y2.push(endY);
     }
+    const categoryOffset = resolveCategorySlotOffset(resolved, layer);
+    if (categoryOffset?.pixels) {
+      const targets = categoryOffset.channel === "x" ? [x1, x2] : [y1, y2];
+      for (const values of targets) {
+        for (let index = 0; index < values.length; index += 1) {
+          if (Number.isFinite(values[index])) values[index] += categoryOffset.pixels;
+        }
+      }
+    }
 
     const resolvedConfig = {
       ...DEFAULT_RULE_CONFIG,
@@ -312,6 +367,7 @@ export const materializeRuleSpan = action(
 export function registerRuleMarkActions(ProgramClass) {
   Object.assign(ProgramClass.prototype, {
     createRuleMark,
+    editRuleMark,
     rematerializeRuleMark,
     materializeRuleSpan
   });

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

@@ -0,0 +1,26 @@
+import { validateRuleStroke, validateRuleStrokeWidth } from "../../../grammar/ruleAppearance.js";
+import { normalizeStrokeDashPattern, validateOpacityValue } from "../../../grammar/scales/index.js";
+
+const STYLE_ACTIONS = Object.freeze({
+  stroke: ["encodeStroke", validateRuleStroke],
+  strokeWidth: ["encodeStrokeWidth", validateRuleStrokeWidth],
+  strokeDash: ["encodeStrokeDash", normalizeStrokeDashPattern],
+  opacity: ["encodeOpacity", validateOpacityValue]
+});
+
+export function planRuleAppearance(args, layer) {
+  return Object.entries(STYLE_ACTIONS).flatMap(([property, [op, validate]]) => {
+    if (!Object.hasOwn(args, property)) return [];
+    if (layer?.encoding?.[property]?.field !== undefined) {
+      throw new Error(`Rule ${property} conflicts with a field encoding; use ${op} with value to replace it.`);
+    }
+    validate(args[property], `Rule ${property}`);
+    return [{ op, value: args[property] }];
+  });
+}
+
+export function applyRuleAppearance(program, target, plan) {
+  let next = program;
+  for (const { op, value } of plan) next = next[op]({ target, value });
+  return next;
+}

package/src/actions/marks/shared.js

@@ -1,8 +1,9 @@
+import { isSourceOwnedText } from "../../grammar/text.js";
 import {
   resolveOptionalUserId,
   validateUserId
 } from "../../core/identifiers.js";
-import { findDataset } from "../../selectors/datasets.js";
+import { findDataset, requireMaterializedDataset } from "../../selectors/datasets.js";
 import { findLayer, hasLayer } from "../../selectors/layers.js";
 import { findSemanticScale } from "../../selectors/scales.js";
 import { resolveMarkPositionPolicy } from "../encodings/position/policies/index.js";
@@ -27,12 +28,7 @@ export function resolveMarkData(program, requested) {
     throw new Error("Mark creation requires data or a current dataset.");
   }
 
-  const dataset = findDataset(program, data);
-
-  if (dataset === undefined) {
-    throw new Error(`Unknown dataset "${data}".`);
-  }
-
+  const dataset = requireMaterializedDataset(program, data);
   return { data, dataset };
 }
 
@@ -60,7 +56,7 @@ export function assertMarkAvailable(program, id) {
     throw new Error(`Mark "${id}" already exists.`);
   }
 
-  if (program.graphicSpec.objects[id] !== undefined) {
+  if (Object.hasOwn(program.graphicSpec.objects, id)) {
     throw new Error(`Graphic "${id}" already exists.`);
   }
 }
@@ -78,9 +74,9 @@ const POSITION_POLICY_SUBSETS = Object.freeze([
 ]);
 
 function inheritedPositionEncodings(encoding) {
-  if (encoding?.field === undefined) return undefined;
+  if (encoding?.field === undefined && encoding?.aggregate !== "count") return undefined;
   const base = Object.fromEntries(
-    ["field", "fieldType", "scale", "title"]
+    ["field", "fieldType", "scale", "title", "temporalUnit"]
       .filter(property => Object.hasOwn(encoding, property))
       .map(property => [property, encoding[property]])
   );
@@ -104,6 +100,9 @@ function inheritedPositionEncodings(encoding) {
 function scaleSupportsEncoding(program, markType, channel, encoding) {
   const scale = findSemanticScale(program, encoding.scale);
   if (scale === undefined) return false;
+  if (scale.radialMapping !== undefined) {
+    return markType === "arc" && channel === "radius" && ["count", "sum"].includes(encoding.aggregate);
+  }
   const categorical = ["nominal", "ordinal"].includes(encoding.fieldType);
   if (categorical) {
     if (["bar", "rect"].includes(markType)) return scale.type === "band";
@@ -143,7 +142,8 @@ export function resolveCompatibleEncodings(program, source, markType) {
             layer: candidate,
             dataset,
             channel,
-            args: encoding,
+            args: { ...encoding, ...(channel === "radius" && findSemanticScale(program, encoding.scale)?.radialMapping !== undefined
+              ? { mapping: findSemanticScale(program, encoding.scale).radialMapping } : {}) },
             field: encoding.field,
             fieldType: encoding.fieldType
           });
@@ -163,7 +163,7 @@ export function resolveCompatibleEncodings(program, source, markType) {
 }
 
 function eligibleLayeredSource(program, layer, requestedData, markType) {
-  if (layer?.data === undefined) return false;
+  if (layer?.data === undefined || isSourceOwnedText(layer)) return false;
   if (requestedData !== undefined && layer.data !== requestedData) return false;
   return Object.keys(resolveCompatibleEncodings(program, layer, markType)).length > 0;
 }