ggaction 0.0.21 → 0.0.23

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

@@ -1,152 +1 @@
-import {
-  validateAggregate,
-  validateAggregateFieldType
-} from "../../../../grammar/aggregate.js";
-import { emptyPositionPolicy, resolveBin } from "./common.js";
-
-function rejectStack(args, channel) {
-  if (args.stack !== undefined) {
-    throw new Error(`Line ${channel} encoding does not support stack.`);
-  }
-}
-
-function rejectBin(args, channel) {
-  if (args.bin !== undefined) {
-    throw new Error(`Line ${channel} encoding does not support bin.`);
-  }
-}
-
-export function resolveLinePositionPolicy({
-  program,
-  layer,
-  dataset,
-  channel,
-  args,
-  fieldType
-}) {
-  const polar = ["theta", "radius"].includes(channel);
-  const config = program.markConfigs[layer.id] ?? {};
-  if (polar) {
-    if (config.curve !== undefined && config.curve !== "linear") {
-      throw new Error("Polar line position currently requires curve \"linear\".");
-    }
-    rejectBin(args, channel);
-    rejectStack(args, channel);
-    if (args.aggregate !== undefined) {
-      throw new Error(`Line ${channel} encoding does not support aggregate.`);
-    }
-    return emptyPositionPolicy();
-  }
-  if (config.closed === true) {
-    throw new Error("Line closed requires theta/radius Polar position encodings.");
-  }
-  const regression = dataset.transform?.some(item => item.type === "regression");
-  const interval = dataset.transform?.some(item => item.type === "interval");
-  const windowOutput = dataset.transform?.some(item =>
-    item.type === "window" &&
-    item.operations?.some(operation => operation.as === args.field)
-  );
-
-  if (channel === "x") {
-    rejectStack(args, "x");
-    if (args.aggregate !== undefined) {
-      throw new Error("Line x encoding does not support aggregate.");
-    }
-    if (args.bin !== undefined) {
-      if (fieldType !== "quantitative") {
-        throw new Error("Binned line x encoding requires a quantitative field.");
-      }
-      if (
-        layer.encoding?.y !== undefined &&
-        layer.encoding.y.aggregate === undefined
-      ) {
-        throw new Error("Binned line x encoding requires an aggregate y encoding.");
-      }
-      return {
-        bin: resolveBin(args.bin),
-        aggregate: undefined,
-        stack: undefined
-      };
-    }
-    if (["nominal", "ordinal"].includes(fieldType)) {
-      if (layer.encoding?.y !== undefined && layer.encoding.y.aggregate === undefined &&
-          layer.encoding.y.fieldType !== "quantitative") {
-        throw new Error("Categorical line x requires a quantitative value or aggregate y encoding.");
-      }
-      return emptyPositionPolicy();
-    }
-    const directPair =
-      layer.encoding?.y?.aggregate === undefined &&
-      ["quantitative", "temporal"].includes(layer.encoding?.y?.fieldType) &&
-      fieldType === "quantitative";
-    const pendingQuantitativePair =
-      layer.encoding?.y === undefined && fieldType === "quantitative";
-    if (
-      fieldType !== "temporal" &&
-      !(
-        (regression || interval || directPair || pendingQuantitativePair) &&
-        fieldType === "quantitative"
-      )
-    ) {
-      throw new Error(
-        "Line x encoding requires a categorical or temporal field, or a compatible quantitative field."
-      );
-    }
-    return emptyPositionPolicy();
-  }
-
-  rejectBin(args, "y");
-  rejectStack(args, "y");
-  if (layer.encoding?.x?.bin !== undefined && args.aggregate === undefined) {
-    throw new Error("Binned line x encoding requires an aggregate y encoding.");
-  }
-  if (["nominal", "ordinal"].includes(layer.encoding?.x?.fieldType) &&
-      args.aggregate === undefined && fieldType !== "quantitative") {
-    throw new Error("Categorical line x requires a quantitative value or aggregate y encoding.");
-  }
-  const continuousPair =
-    fieldType === "quantitative" &&
-    ["quantitative", "temporal", "nominal", "ordinal"].includes(layer.encoding?.x?.fieldType) &&
-    layer.encoding.x.bin === undefined;
-  const prospectiveDirect =
-    args.aggregate === undefined &&
-    (fieldType === "temporal" ||
-      (fieldType === "quantitative" &&
-        (layer.encoding?.x === undefined || continuousPair)));
-  if (interval || (windowOutput && args.aggregate === undefined) || prospectiveDirect) {
-    if (!["quantitative", "temporal"].includes(fieldType)) {
-      throw new Error(
-        "Direct line y encoding requires a quantitative or temporal field."
-      );
-    }
-    if (args.aggregate !== undefined) {
-      throw new Error("Direct line y encoding does not support aggregate.");
-    }
-    return emptyPositionPolicy();
-  }
-  if (regression) {
-    if (fieldType !== "quantitative") {
-      throw new Error("Regression line y encoding requires a quantitative field.");
-    }
-    if (args.aggregate !== undefined) {
-      throw new Error("Regression line y encoding does not support aggregate.");
-    }
-    return emptyPositionPolicy();
-  }
-
-  if (layer.encoding?.x !== undefined) {
-    const compatibleAggregateX =
-      ["temporal", "nominal", "ordinal"].includes(layer.encoding.x.fieldType) ||
-      (layer.encoding.x.fieldType === "quantitative" &&
-        layer.encoding.x.bin !== undefined);
-    if (!compatibleAggregateX) {
-      throw new Error(
-        "Aggregate line y encoding requires a temporal, categorical, or binned quantitative x encoding."
-      );
-    }
-  }
-
-  const aggregate = validateAggregate(args.aggregate);
-  validateAggregateFieldType(aggregate, fieldType);
-  return { bin: undefined, aggregate, stack: undefined };
-}
+import{validateAggregate as E,validateAggregateFieldType as b}from"../../../../grammar/aggregate.js";import{emptyPositionPolicy as a,resolveBin as h}from"./common.js";import{findSemanticScale as P}from"../../../../selectors/scales.js";import{validateCategoricalColorConsumer as L}from"../../../../grammar/scales/colorConsumers.js";import{validateLineMissingScope as k}from"../../../../grammar/lineMissing.js";function u(d,e){if(d.stack!==void 0)throw new Error(`Line ${e} encoding does not support stack.`)}function p(d,e){if(d.bin!==void 0)throw new Error(`Line ${e} encoding does not support bin.`)}function $({program:d,layer:e,dataset:g,channel:o,args:n,fieldType:i}){k({...e,encoding:{...e.encoding,[o]:{...n,fieldType:i}}});for(const t of["color","strokeDash"]){const r=e.encoding?.[t],l=r===void 0?void 0:P(d,r.scale);l!==void 0&&L({...e,encoding:{...e.encoding,[o]:{...e.encoding[o],...n,fieldType:i}}},r,l,t)}const m=["theta","radius"].includes(o),c=d.markConfigs[e.id]??{};if(m){if(c.curve!==void 0&&c.curve!=="linear")throw new Error('Polar line position currently requires curve "linear".');if(p(n,o),u(n,o),n.aggregate!==void 0)throw new Error(`Line ${o} encoding does not support aggregate.`);return a()}if(c.closed===!0)throw new Error("Line closed requires theta/radius Polar position encodings.");const f=g.transform?.some(t=>t.type==="regression"),s=g.transform?.some(t=>t.type==="interval"),v=g.transform?.some(t=>t.type==="window"&&t.operations?.some(r=>r.as===n.field));if(o==="x"){if(u(n,"x"),n.aggregate!==void 0)throw new Error("Line x encoding does not support aggregate.");if(n.bin!==void 0){if(i!=="quantitative")throw new Error("Binned line x encoding requires a quantitative field.");if(e.encoding?.y!==void 0&&e.encoding.y.aggregate===void 0)throw new Error("Binned line x encoding requires an aggregate y encoding.");return{bin:h(n.bin),aggregate:void 0,stack:void 0}}if(["nominal","ordinal"].includes(i)){if(e.encoding?.y!==void 0&&e.encoding.y.aggregate===void 0&&e.encoding.y.fieldType!=="quantitative")throw new Error("Categorical line x requires a quantitative value or aggregate y encoding.");return a()}const t=e.encoding?.y?.aggregate===void 0&&["quantitative","temporal"].includes(e.encoding?.y?.fieldType)&&i==="quantitative",r=e.encoding?.y===void 0&&i==="quantitative";if(i!=="temporal"&&!((f||s||t||r)&&i==="quantitative"))throw new Error("Line x encoding requires a categorical or temporal field, or a compatible quantitative field.");return a()}if(p(n,"y"),u(n,"y"),e.encoding?.x?.bin!==void 0&&n.aggregate===void 0)throw new Error("Binned line x encoding requires an aggregate y encoding.");if(["nominal","ordinal"].includes(e.encoding?.x?.fieldType)&&n.aggregate===void 0&&i!=="quantitative")throw new Error("Categorical line x requires a quantitative value or aggregate y encoding.");const q=i==="quantitative"&&["quantitative","temporal","nominal","ordinal"].includes(e.encoding?.x?.fieldType)&&e.encoding.x.bin===void 0,x=n.aggregate===void 0&&(i==="temporal"||i==="quantitative"&&(e.encoding?.x===void 0||q));if(s||v&&n.aggregate===void 0||x){if(!["quantitative","temporal"].includes(i))throw new Error("Direct line y encoding requires a quantitative or temporal field.");if(n.aggregate!==void 0)throw new Error("Direct line y encoding does not support aggregate.");return a()}if(f){if(i!=="quantitative")throw new Error("Regression line y encoding requires a quantitative field.");if(n.aggregate!==void 0)throw new Error("Regression line y encoding does not support aggregate.");return a()}if(e.encoding?.x!==void 0&&!(["temporal","nominal","ordinal"].includes(e.encoding.x.fieldType)||e.encoding.x.fieldType==="quantitative"&&e.encoding.x.bin!==void 0))throw new Error("Aggregate line y encoding requires a temporal, categorical, or binned quantitative x encoding.");const w=E(n.aggregate);return b(w,i),{bin:void 0,aggregate:w,stack:void 0}}export{$ as resolveLinePositionPolicy};

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

@@ -1,6 +1,7 @@
 import { isSourceOwnedText } from "../../../grammar/text.js";
 import { findSemanticScale } from "../../../selectors/scales.js";
 import { readAreaEndpoint } from "../../../grammar/areaEndpoints.js";
+import { readLinePosition } from "../../../grammar/lineMissing.js";
 import { validateUserId } from "../../../core/identifiers.js";
 import { getPositionCoordinateDefaults } from "../../../grammar/coordinates.js";
 import {
@@ -272,7 +273,9 @@ export function resolvePositionEncoding(program, channel, args, operation) {
       "Position scale unknown currently requires a row-owned point mark."
     );
   }
-  if (layer.mark.type === "area" && fieldType === "quantitative") {
+  if (layer.mark.type === "line" && layer.mark.missing === "break") {
+    readLinePosition(dataset.values, { field, fieldType, temporalUnit });
+  } else if (layer.mark.type === "area" && fieldType === "quantitative") {
     readAreaEndpoint(dataset.values, { ...(hasDatum ? { datum } : { field }), fieldType }, layer.mark.missing);
   } else if (["rule", "rect", "text", "point", "tick"].includes(layer.mark.type) && hasDatum) {
     const mark = layer.mark.type[0].toUpperCase() + layer.mark.type.slice(1);

package/src/actions/encodings/ranged.js

@@ -199,6 +199,39 @@ const encodeY2 = /* @__PURE__ */ action(
   }
 );
 
+function normalizeDatumRangeBound(value, fieldType, operation) {
+  if (typeof value === "string") return { field: value };
+  validateOptions(value, ["datum"], `${operation} endpoint`);
+  if (!Object.hasOwn(value, "datum") || fieldType !== "quantitative") {
+    throw new TypeError(`${operation} datum endpoints require a quantitative datum object.`);
+  }
+  return { datum: normalizePositionDatum(value.datum, fieldType, operation, undefined, "Range") };
+}
+
+function prepareDatumRange(program, layer, dataset, channel, args, common, lower, upper) {
+  if (Object.hasOwn(upper, "field")) {
+    validateSecondaryField(applyRequestedItemMissingPolicy(layer, dataset, upper.field),
+      upper.field, common.fieldType, undefined);
+  }
+  const resolved = resolvePositionEncoding(program, channel, {
+    ...common, ...lower,
+    ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate }),
+    ...(args.scale === undefined ? {} : { scale: args.scale })
+  }, channel === "x" ? "encodeXRange" : "encodeYRange");
+  const primary = { ...lower, fieldType: common.fieldType, scale: resolved.scale.id };
+  const secondary = { ...upper, fieldType: common.fieldType, scale: resolved.scale.id };
+  const updated = { ...layer, coordinate: resolved.coordinate.id,
+    encoding: { ...layer.encoding, [channel]: primary, [`${channel}2`]: secondary } };
+  const coordinates = program.semanticSpec.coordinates;
+  resolveScalePreview({ ...program, semanticSpec: { ...program.semanticSpec,
+    layers: program.semanticSpec.layers.map(item => item.id === layer.id ? updated : item),
+    coordinates: coordinates.some(item => item.id === resolved.coordinate.id)
+      ? coordinates : [...coordinates, resolved.coordinate],
+    scales: [...program.semanticSpec.scales.filter(item => item.id !== resolved.scale.id), resolved.scale]
+  } }, resolved.scale.id);
+  return secondary;
+}
+
 function rangeAction(channel) {
   const primary = channel === "x" ? "encodeX" : "encodeY";
   const secondary = channel === "x" ? "encodeX2" : "encodeY2";
@@ -213,6 +246,19 @@ function rangeAction(channel) {
     const { layer, dataset } = resolveTarget(this, args.target, ["area", "bar", "rect", "rule"], "ranged mark");
     let next = this;
     let lower = { field: args.lower }, upper = { field: args.upper };
+    if (layer.mark.type === "rect" || layer.mark.type === "rule") {
+      lower = normalizeDatumRangeBound(args.lower, common.fieldType, op);
+      upper = normalizeDatumRangeBound(args.upper, common.fieldType, op);
+      if (Object.hasOwn(lower, "datum") || Object.hasOwn(upper, "datum")) {
+        common.target = layer.id;
+        const prepared = prepareDatumRange(this, layer, dataset, channel, args, common, lower, upper);
+        const secondaryChannel = `${channel}2`;
+        if (layer.encoding?.[secondaryChannel] !== undefined) {
+          next = next.editSemantic({ property: `layer[${layer.id}].encoding.${secondaryChannel}`, remove: true });
+        }
+        next = setEncodingProperties(next, layer.id, secondaryChannel, prepared);
+      }
+    }
     if (layer.mark.type === "bar") {
       if (layer.mark.orientation !== undefined && channel !== (layer.mark.orientation === "vertical" ? "y" : "x")) {
         throw new Error("Numeric bar endpoints must use the measure channel.");

package/src/actions/encodings/remove.js

@@ -33,7 +33,7 @@ const OPTIONS = Object.freeze(["target", "channel"]);
 const REMOVABLE_CHANNELS = Object.freeze([
   "x", "y", "x2", "y2", "xOffset", "yOffset", "theta", "radius",
   "color", "stroke", "strokeDash", "strokeWidth", "size", "shape", "group",
-  "angle", "opacity", "text"
+  "angle", "opacity", "text", "dx", "dy"
 ]);
 const REMOVE_AXIS = Object.freeze({
   x: "removeXAxis",

package/src/actions/encodings/ruleAppearance.js

@@ -1,3 +1,4 @@
+import { APPEARANCE_MARK_TYPES } from "../../core/vocabulary.js";
 import { action } from "../../core/action.js";
 import { validateRuleStrokeWidth } from "../../grammar/ruleAppearance.js";
 import { readQuantitativeField } from "../../grammar/scales/index.js";
@@ -24,7 +25,7 @@ const WIDTH_OPTIONS = Object.freeze([
 const encodeStrokeWidth = /* @__PURE__ */ action(
   {
     op: "encodeStrokeWidth",
-    description: "Assign constant or field-driven line or rule stroke width."
+    description: "Assign constant or field-driven mark stroke width."
   },
   function (args = {}) {
     validateOptions(args, WIDTH_OPTIONS, "encodeStrokeWidth");
@@ -38,7 +39,7 @@ const encodeStrokeWidth = /* @__PURE__ */ action(
         throw new Error("Constant stroke width does not accept fieldType or scale.");
       }
       validateRuleStrokeWidth(args.value);
-      const { id, layer } = resolveTarget(this, args.target, ["rule", "line"], "rule or line mark");
+      const { id, layer } = resolveTarget(this, args.target, APPEARANCE_MARK_TYPES.encodeStrokeWidth, "rule, line or rect mark");
       assertEncodingSelectionCompatibility(this, id, ["strokeWidth"]);
       let next = this.guideConfigs.legend?.strokeWidth?.target === id
         ? this.removeLegend({ target: id, channels: ["strokeWidth"] })
@@ -53,7 +54,7 @@ const encodeStrokeWidth = /* @__PURE__ */ action(
           ...next.markConfigs[id],
           strokeWidth: args.value
         });
-      if (layer.mark.type === "line") {
+      if (["line", "rect"].includes(layer.mark.type)) {
         return rematerializeEncoding(next, id, "strokeWidth", undefined, layer);
       }
       next = next.rematerializeRuleMark({ id });
@@ -62,8 +63,8 @@ const encodeStrokeWidth = /* @__PURE__ */ action(
     const { id, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
-      ["rule", "line"],
-      "rule or line mark"
+      APPEARANCE_MARK_TYPES.encodeStrokeWidth,
+      "rule, line or rect mark"
     );
     const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
     const fieldType = args.fieldType ?? "quantitative";
@@ -78,7 +79,7 @@ const encodeStrokeWidth = /* @__PURE__ */ action(
     }
     validatePathSeriesAppearance(dataset.values, {
       ...layer, encoding: { ...layer.encoding, strokeWidth: { field: args.field, fieldType } }
-    });
+    }, this.semanticSpec.scales);
     const previous = layer.encoding?.strokeWidth;
     const requestedScale = resolveReassignmentScaleOptions(
       previous,

package/src/actions/encodings/shared.js

@@ -1,3 +1,6 @@
+import { editScaleForEncoding } from "../scales/edit.js";
+import { collectResourceReferences } from "../../core/resourceReferences.js";
+import { removeScale } from "../resources/remove.js";
 import { cartesianAxisOwners } from "../../selectors/axes.js";
 import { isSourceOwnedText } from "../../grammar/text.js";
 import { validateUserId } from "../../core/identifiers.js";
@@ -60,6 +63,15 @@ export function resolveReassignmentScaleOptions(encoding, options) {
   return { ...options, id: encoding.scale };
 }
 
+// A fixed-to-field transition may reuse a detached named channel scale with
+// changed options. Recreate it through the existing resource owner, preserving
+// the resolved definition's omitted defaults and never touching live consumers.
+export function releaseDetachedEncodingScale(program, id) {
+  if (findSemanticScale(program, id) === undefined ||
+      collectResourceReferences(program, { kind: "scale", id }).some(ref => ref.strength === "live")) return program;
+  return removeScale.call(program, { id });
+}
+
 export function applyEncodingScale(
   program,
   definition,
@@ -71,7 +83,7 @@ export function applyEncodingScale(
     return program.createScale(definition);
   }
   if (existing.type !== definition.type) {
-    if (reassignment && allowTypeChange) return program.editScale({ ...definition });
+    if (reassignment && allowTypeChange) return editScaleForEncoding(program, { ...definition });
     throw new Error(
       `Scale "${definition.id}" cannot change type from "${existing.type}" to "${definition.type}".`
     );
@@ -89,7 +101,7 @@ export function applyEncodingScale(
 
   return Object.keys(patch).length === 1 || !reassignment
     ? program.createScale(definition)
-    : program.editScale(patch);
+    : editScaleForEncoding(program, patch);
 }
 
 export function rebindPositionGuides(

package/src/actions/encodings/stroke.js

@@ -1,3 +1,4 @@
+import { APPEARANCE_MARK_TYPES } from "../../core/vocabulary.js";
 import { action } from "../../core/action.js";
 import {
   readNominalField,
@@ -7,9 +8,10 @@ import {
   resolveTemporalUnit,
   validateCategoricalFieldType
 } from "../../grammar/scales/index.js";
-import { validateContinuousColorConsumer } from
+import { validateContinuousColorConsumer, validateTickColorChannels } from
   "../../grammar/scales/colorConsumers.js";
-import { validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
+import { validatePathGroupAppearance } from "../../materialization/marks/grouping.js";
+import { resolveColorReassignmentScaleOptions } from "./color/policy.js";
 import { validateRuleStroke } from "../../grammar/ruleAppearance.js";
 import { assertEncodingSelectionCompatibility } from
   "../../materialization/selection/compatibility.js";
@@ -20,8 +22,8 @@ import {
 import { applyTemporalUnit } from "./temporal.js";
 import {
   applyEncodingScale,
+  releaseDetachedEncodingScale,
   rematerializeEncoding,
-  resolveReassignmentScaleOptions,
   resolveTarget,
   setEncodingProperties,
   validateOptions
@@ -32,9 +34,7 @@ import { applyRequestedItemMissingPolicy } from
 const OPTIONS = Object.freeze([
   "target", "value", "field", "fieldType", "temporalUnit", "scale"
 ]);
-const MARK_TYPES = Object.freeze([
-  "point", "line", "area", "bar", "rect", "arc", "rule", "tick"
-]);
+const MARK_TYPES = APPEARANCE_MARK_TYPES.encodeStroke;
 
 function withoutConstantStroke(program, layer) {
   const config = { ...program.markConfigs[layer.id] };
@@ -79,17 +79,17 @@ function hasStrokeLegend(program, target) {
   );
 }
 
-function validateStrokeField(dataset, layer, args, scale, temporalUnit) {
+function validateStrokeField(program, dataset, layer, args, scale, temporalUnit) {
   const { field, fieldType } = args;
   validateContinuousColorConsumer(layer, args, scale, { channel: "stroke" });
   if (["line", "area"].includes(layer.mark.type)) {
-    validatePathSeriesAppearance(dataset.values, {
+    validatePathGroupAppearance(program, {
       ...layer,
       encoding: {
         ...layer.encoding,
         stroke: { field, fieldType, temporalUnit, scale: scale.id }
       }
-    });
+    }, dataset);
   }
   if (Object.hasOwn(scale, "unknown")) {
     readScaleField(dataset.values, field, fieldType, {
@@ -130,6 +130,7 @@ export const encodeStroke = /* @__PURE__ */ action(
       MARK_TYPES,
       "stroke-capable mark"
     );
+    validateTickColorChannels(layer, "stroke");
 
     if (hasValue) {
       const value = validateRuleStroke(args.value);
@@ -160,8 +161,8 @@ export const encodeStroke = /* @__PURE__ */ action(
     const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
     const previous = layer.encoding?.stroke;
     const temporalUnit = resolveTemporalUnit(args, fieldType, previous);
-    const requestedScale = resolveReassignmentScaleOptions(
-      previous,
+    const requestedScale = resolveColorReassignmentScaleOptions(
+      this, layer, "stroke", fieldType,
       args.scale ?? {}
     );
     let scale;
@@ -179,7 +180,7 @@ export const encodeStroke = /* @__PURE__ */ action(
         readNominalField(dataset.values, args.field);
       }
       if (["line", "area"].includes(layer.mark.type)) {
-        validatePathSeriesAppearance(dataset.values, {
+        validatePathGroupAppearance(this, {
           ...layer,
           encoding: {
             ...layer.encoding,
@@ -189,7 +190,7 @@ export const encodeStroke = /* @__PURE__ */ action(
               scale: scale.id
             }
           }
-        });
+        }, dataset);
       }
     } else if (["quantitative", "temporal"].includes(fieldType)) {
       scale = resolveQuantitativeColorScaleDefinition(
@@ -199,17 +200,22 @@ export const encodeStroke = /* @__PURE__ */ action(
         "stroke"
       );
       validateStrokeField(
+        this,
         dataset,
         layer,
         { ...args, fieldType },
         scale,
-        temporalUnit
+        temporalUnit,
+        this.semanticSpec.scales
       );
     } else {
       throw new Error(`Unsupported stroke field type "${fieldType}".`);
     }
 
     let next = withoutConstantStroke(this, layer);
+    if (this.markConfigs[target]?.stroke !== undefined || this.markConfigs[target]?.barAppearance?.stroke !== undefined) {
+      next = releaseDetachedEncodingScale(next, scale.id);
+    }
     next = applyTemporalUnit(next, target, "stroke", temporalUnit, previous);
     next = setEncodingProperties(next, target, "stroke", {
       field: args.field,

package/src/actions/encodings/strokeDash.js

@@ -1,8 +1,9 @@
+import { APPEARANCE_MARK_TYPES } from "../../core/vocabulary.js";
 import { action } from "../../core/action.js";
 import {
   normalizeStrokeDashPattern,
   readNominalField,
-  validateNominalFieldType
+  validateCategoricalFieldType
 } from "../../grammar/scales/index.js";
 import { resolveStrokeDashScaleDefinition } from "../scales/definitions.js";
 import {
@@ -14,6 +15,7 @@ import {
   validateOptions
 } from "./shared.js";
 import { findLayer } from "../../selectors/layers.js";
+import { validateCategoricalColorConsumer } from "../../grammar/scales/colorConsumers.js";
 import { validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
 import { applyRequestedItemMissingPolicy } from
   "../../grammar/itemMissing.js";
@@ -63,7 +65,7 @@ function reconcileLegendAfterDashRemoval(program, target) {
 const encodeStrokeDash = /* @__PURE__ */ action(
   {
     op: "encodeStrokeDash",
-    description: "Encode a nominal field as line stroke dash."
+    description: "Encode a categorical field as line stroke dash."
   },
   function (args = {}) {
     validateOptions(args, STROKE_DASH_ENCODING_OPTIONS, "encodeStrokeDash");
@@ -78,7 +80,7 @@ const encodeStrokeDash = /* @__PURE__ */ action(
     const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
-      ["line", "rule"],
+      APPEARANCE_MARK_TYPES.encodeStrokeDash,
       "line or rule mark"
     );
     const dataset = hasField
@@ -88,7 +90,7 @@ const encodeStrokeDash = /* @__PURE__ */ action(
       normalizeStrokeDashPattern(args.value);
       validatePathSeriesAppearance(dataset.values, {
         ...layer, encoding: { ...layer.encoding, strokeDash: { datum: args.value } }
-      });
+      }, this.semanticSpec.scales);
       let next = layer.encoding?.strokeDash === undefined
         ? this
         : this.clearStrokeDashEncoding({ target });
@@ -100,20 +102,16 @@ const encodeStrokeDash = /* @__PURE__ */ action(
       return rematerializeEncoding(next, target, "strokeDash", undefined, layer);
     }
 
-    const fieldType = validateNominalFieldType(args.fieldType ?? "nominal");
+    const fieldType = validateCategoricalFieldType(args.fieldType ?? "nominal");
     validatePathSeriesAppearance(dataset.values, {
       ...layer, encoding: { ...layer.encoding, strokeDash: { field: args.field, fieldType } }
-    });
+    }, this.semanticSpec.scales);
     const previous = layer.encoding?.strokeDash;
     const requestedScale = previous?.field === args.field
       ? resolveReassignmentScaleOptions(previous, args.scale ?? {})
       : args.scale ?? {};
     const scale = resolveStrokeDashScaleDefinition(this, requestedScale);
-    if (Object.hasOwn(scale, "unknown")) {
-      throw new Error(
-        "StrokeDash scale unknown is not supported for grouped line or rule paths."
-      );
-    }
+    validateCategoricalColorConsumer(layer, { field: args.field, fieldType }, scale, "strokeDash");
     readNominalField(dataset.values, args.field);
 
     let next = previous === undefined

package/src/actions/encodings/text.js

@@ -1,10 +1,11 @@
 import { action } from "../../core/action.js";
 import { schemaField } from "../../grammar/datasetSchema.js";
-import { formatTextValue, validateTextFormat } from "../../grammar/text.js";
+import { formatTextValue, validateTextFormat, isIndependentText, resolveTextOffsetDataset, normalizeTextOffsetAssignment } from "../../grammar/text.js";
+import { validateUserId } from "../../core/identifiers.js";
 import { normalizeMarkLabelContent, resolveMarkLabelValues } from "../../grammar/markLabels.js";
 import { canMaterializeText } from "../../materialization/marks/index.js";
 import { resolveMarkItems } from "../../materialization/selection/policies/index.js";
-import { findLayer } from "../../selectors/layers.js";
+import { findLayer, resolveEligibleLayer } from "../../selectors/layers.js";
 import {
   resolveTarget,
   setEncodingProperties,
@@ -90,6 +91,33 @@ export const encodeText = /* @__PURE__ */ action(
   }
 );
 
+function createTextOffsetEncoding(channel) {
+  const operation = channel === "dx" ? "encodeDx" : "encodeDy";
+  return action({ op: operation, description: `Assign direct numeric ${channel} pixel offsets to independent Text.` }, function (args = {}) {
+    const properties = normalizeTextOffsetAssignment(args, channel);
+    const selected = resolveEligibleLayer(this, {
+      target: args.target === undefined ? undefined : validateUserId(args.target, "Text offset target"),
+      predicate: isIndependentText,
+      label: "Independent Text offset"
+    });
+    const { id: target, layer, dataset } = resolveTarget(this, selected.id, ["text"], "independent Text");
+    resolveTextOffsetDataset({ ...layer, encoding: { ...layer.encoding, [channel]: properties } }, dataset);
+    let next = this;
+    for (const property of ["field", "fieldType", "datum"]) {
+      if (Object.hasOwn(layer.encoding?.[channel] ?? {}, property)) {
+        next = next.editSemantic({ property: `layer[${target}].encoding.${channel}.${property}`, remove: true });
+      }
+    }
+    next = setEncodingProperties(next, target, channel, properties);
+    return canMaterializeText(next, findLayer(next, target)) ? next.rematerializeTextMark({ id: target }) : next;
+  });
+}
+
+export const encodeDx = /* @__PURE__ */ createTextOffsetEncoding("dx");
+export const encodeDy = /* @__PURE__ */ createTextOffsetEncoding("dy");
+
 export function registerTextEncodingAction(ProgramClass) {
   ProgramClass.prototype.encodeText = encodeText;
+  ProgramClass.prototype.encodeDx = encodeDx;
+  ProgramClass.prototype.encodeDy = encodeDy;
 }

package/src/actions/errorBars/edit.js

@@ -266,8 +266,8 @@ function updateErrorBarOffsets(program, ids, current, candidate) {
   return next;
 }
 
-function updateErrorBarRoles(program, owner, current, candidate, dataId, capIds) {
-  const owned = [owner.id, ...capIds];
+function updateErrorBarRoles(program, owner, current, candidate, dataId, capIds, centerIds) {
+  const owned = [owner.id, ...capIds, ...centerIds];
   let next = updateErrorBarOffsets(
     program, owned, current, { ...candidate, offset: undefined }
   );
@@ -301,6 +301,18 @@ function updateErrorBarRoles(program, owner, current, candidate, dataId, capIds)
           }
         });
       }
+      for (const id of centerIds) {
+        updated = setCartesianPosition(updated, id, categoryChannel, {
+          field: candidate.position.field,
+          fieldType: candidate.position.fieldType,
+          scale: category.scale
+        });
+        updated = setCartesianPosition(updated, id, measureChannel, {
+          field: candidate.fields.center,
+          fieldType: "quantitative",
+          scale: measure.scale
+        });
+      }
       return updated;
     }
   });
@@ -411,7 +423,12 @@ export const editErrorBar = /* @__PURE__ */ closedAction(
     const capIds = errorBarCaps(current)
       .map(([id]) => id)
       .filter(id => findLayer(this, id) !== undefined);
-    const consumers = collectIntervalConsumers(this, [owner.id, ...capIds]);
+    // createIntervalPlot records the center's ownership explicitly. It must
+    // follow the interval revision just like caps and source-owned labels.
+    const centerIds = this.semanticSpec.layers.filter(layer =>
+      this.markConfigs[layer.id]?.intervalPlot?.intervalId === owner.id
+    ).map(layer => layer.id);
+    const consumers = collectIntervalConsumers(this, [owner.id, ...capIds, ...centerIds]);
     const interval = roleRequested
       ? planIntervalRoleData(this, {
           owner: owner.id,
@@ -442,9 +459,12 @@ export const editErrorBar = /* @__PURE__ */ closedAction(
     });
     next = roleRequested
       ? updateErrorBarRoles(
-          next, owner, current, candidate, interval.dataId, capIds
+          next, owner, current, candidate, interval.dataId, capIds, centerIds
         )
       : next.rematerializeErrorBar({ id: owner.id });
+    if (interval.changed || roleRequested) {
+      for (const id of centerIds) next = next.rematerializePointMark({ id });
+    }
     return releaseIntervalRevision(next, interval);
   }
 );