ggaction 0.0.23 → 0.0.26

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

@@ -26,7 +26,8 @@ import {
   assertNoConstantColor,
   withoutConstantColor,
   resolveColorScaleOptions,
-  resolveColorReassignmentScaleOptions
+  resolveColorReassignmentScaleOptions,
+  withColorLegendReassignment
 } from "./policy.js";
 
 import { applyTemporalUnit } from "../temporal.js";
@@ -85,38 +86,40 @@ export function encodeContinuousColor(program, args) {
   } else {
     readQuantitativeField(dataset.values, args.field);
   }
-  const prepared = baseline === program ? baseline : releaseDetachedEncodingScale(baseline, scale.id);
-  let next = applyTemporalUnit(prepared, target, "color", temporalUnit, layer.encoding?.color)
-    .editSemantic({
-      property: `layer[${target}].encoding.color.field`,
-      value: args.field
-    })
-    .editSemantic({
-      property: `layer[${target}].encoding.color.fieldType`,
-      value: args.fieldType
-    })
-    .editSemantic({
-      property: `layer[${target}].encoding.color.scale`,
-      value: scale.id
-    });
-  if (layer.mark.type === "tick") {
-    const config = { ...next.markConfigs[target] };
-    delete config.stroke;
-    next = next._withMarkConfig(target, config);
-  }
-  const encoded = aggregate === undefined
-    ? next
-    : next.editSemantic({
-        property: `layer[${target}].encoding.color.aggregate`,
-        value: aggregate
+  return withColorLegendReassignment(baseline, layer, scale, candidate => {
+    const prepared = baseline === program ? candidate : releaseDetachedEncodingScale(candidate, scale.id);
+    let next = applyTemporalUnit(prepared, target, "color", temporalUnit, layer.encoding?.color)
+      .editSemantic({
+        property: `layer[${target}].encoding.color.field`,
+        value: args.field
+      })
+      .editSemantic({
+        property: `layer[${target}].encoding.color.fieldType`,
+        value: args.fieldType
+      })
+      .editSemantic({
+        property: `layer[${target}].encoding.color.scale`,
+        value: scale.id
       });
-  const scaled = encoded.setQuantitativeColorScale(scale);
-  return applyDetachedScaleRematerialization(applyMaterializationPlan(
-    scaled,
-    planEncodingRematerialization(scaled, {
-      target,
-      channel: "color",
-      scale: scale.id
-    })
-  ), [layer]);
+    if (layer.mark.type === "tick") {
+      const config = { ...next.markConfigs[target] };
+      delete config.stroke;
+      next = next._withMarkConfig(target, config);
+    }
+    const encoded = aggregate === undefined
+      ? next
+      : next.editSemantic({
+          property: `layer[${target}].encoding.color.aggregate`,
+          value: aggregate
+        });
+    const scaled = encoded.setQuantitativeColorScale(scale);
+    return applyDetachedScaleRematerialization(applyMaterializationPlan(
+      scaled,
+      planEncodingRematerialization(scaled, {
+        target,
+        channel: "color",
+        scale: scale.id
+      })
+    ), [layer]);
+  });
 }

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

@@ -1,9 +1,11 @@
+import { withGuideLayoutValidation } from "../../../materialization/guides/layout.js";
+import { findLayer } from "../../../selectors/layers.js";
 import { findRaincloudParent } from "../../../selectors/raincloud.js";
 import { APPEARANCE_MARK_TYPES } from "../../../core/vocabulary.js";
 import { removeEncoding } from "../remove.js";
 import { validateNonEmptyString } from "../../../core/validation.js";
 import { inferSeriesGroup } from "../shared.js";
-import { action } from "../../../core/action.js";
+import { action, invokeWrappedActionImplementation } from "../../../core/action.js";
 import {
   readNominalField,
   readScaleField,
@@ -41,7 +43,8 @@ import {
   COLOR_ENCODING_OPTIONS,
   resolveColorLayout,
   resolveColorScaleOptions,
-  resolveColorReassignmentScaleOptions
+  resolveColorReassignmentScaleOptions,
+  withColorLegendReassignment
 } from "./policy.js";
 
 import { applyTemporalUnit } from "../temporal.js";
@@ -53,7 +56,7 @@ const encodeColor = /* @__PURE__ */ action(
     op: "encodeColor",
     description: "Assign constant or field-driven graphical color."
   },
-  function (args = {}) {
+  withGuideLayoutValidation(function (args = {}) {
     validateOptions(args, COLOR_ENCODING_OPTIONS, "encodeColor");
     const hasValue = Object.hasOwn(args, "value");
     if (hasValue === Object.hasOwn(args, "field")) {
@@ -64,6 +67,12 @@ const encodeColor = /* @__PURE__ */ action(
       const { target, ...color } = args;
       return this.editRaincloudPlot({ target, color });
     }
+    const overlayTarget = findLayer(this, args.target ?? this.context.currentMark);
+    if (overlayTarget?.derivedBindings?.overlay?.inheritColor) {
+      const next = this.editSemantic({ property: `layer[${overlayTarget.id}].derivedBindings.overlay`,
+        value: { ...overlayTarget.derivedBindings.overlay, inheritColor: false } });
+      return invokeWrappedActionImplementation(encodeColor, next, args);
+    }
     if (hasValue) {
       if (COLOR_ENCODING_OPTIONS.some(key => !["target", "value"].includes(key) && args[key] !== undefined)) {
         throw new Error("Constant color accepts only value and target.");
@@ -160,50 +169,55 @@ const encodeColor = /* @__PURE__ */ action(
       readNominalField(dataset.values, args.field);
     }
 
-    const prepared = baseline === this ? baseline : releaseDetachedEncodingScale(baseline, scale.id);
-    let next = layer.mark.type === "bar" || createsCenterGroup
-      ? inferSeriesGroup(prepared, layer, args.field, "color")
-      : prepared;
-    next = applyTemporalUnit(next, target, "color", undefined, layer.encoding?.color).editSemantic({
-      property: `layer[${target}].encoding.color.field`,
-      value: args.field
-    })
-      .editSemantic({
-        property: `layer[${target}].encoding.color.fieldType`,
-        value: fieldType
+    return withColorLegendReassignment(baseline, layer, scale, candidate => {
+      const prepared = baseline === this ? candidate : releaseDetachedEncodingScale(candidate, scale.id);
+      let next = layer.mark.type === "bar" || createsCenterGroup
+        ? inferSeriesGroup(prepared, layer, args.field, "color")
+        : prepared;
+      next = applyTemporalUnit(next, target, "color", undefined, layer.encoding?.color).editSemantic({
+        property: `layer[${target}].encoding.color.field`,
+        value: args.field
       })
-      .editSemantic({
-        property: `layer[${target}].encoding.color.scale`,
-        value: scale.id
+        .editSemantic({
+          property: `layer[${target}].encoding.color.fieldType`,
+          value: fieldType
+        })
+        .editSemantic({
+          property: `layer[${target}].encoding.color.scale`,
+          value: scale.id
+        });
+      if (layout !== undefined && (layer.mark.type === "arc" || horizonTransform !== undefined)) {
+        next = next.editSemantic({
+          property: `layer[${target}].encoding.color.layout`,
+          value: layout
+        });
+      }
+      if (layer.encoding?.color?.aggregate !== undefined) {
+        next = next.editSemantic({ property: `layer[${target}].encoding.color.aggregate`, remove: true });
+      }
+      next = applyEncodingScale(next, scale, requestedScale, {
+        reassignment: layer.encoding?.color?.scale === scale.id,
+        allowTypeChange: true
       });
-    if (layout !== undefined && (layer.mark.type === "arc" || horizonTransform !== undefined)) {
-      next = next.editSemantic({
-        property: `layer[${target}].encoding.color.layout`,
-        value: layout
+      next = applyColorLayoutCompanion(next, {
+        target,
+        layer,
+        layout,
+        scale,
+        field: args.field,
+        horizon: horizonTransform !== undefined
       });
-    }
-    next = applyEncodingScale(next, scale, requestedScale, {
-      reassignment: layer.encoding?.color?.scale === scale.id,
-      allowTypeChange: true
-    });
-    next = applyColorLayoutCompanion(next, {
-      target,
-      layer,
-      layout,
-      scale,
-      field: args.field,
-      horizon: horizonTransform !== undefined
-    });
 
-    return applyDetachedScaleRematerialization(applyMaterializationPlan(
-      next,
-      planEncodingRematerialization(next, {
-        target,
-        channel: "color",
-        scale: scale.id
-      })
-    ), [layer]);
-  }
+      return applyDetachedScaleRematerialization(applyMaterializationPlan(
+        next,
+        planEncodingRematerialization(next, {
+          target,
+          channel: "color",
+          scale: scale.id
+        })
+      ), [layer]);
+    });
+  })
 );
 
 export function registerColorEncodingAction(ProgramClass) {

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

@@ -1,3 +1,5 @@
+import { findSemanticScale } from "../../../selectors/scales.js";
+import { planColorLegendTransitions, applyColorLegendTransition } from "../../guides/legends/transition.js";
 import {
   BAR_GRAINS,
   inferBarColorLayout,
@@ -146,3 +148,16 @@ export function resolveColorLayout(layer, requested, barGrain, field) {
   }
   return layout;
 }
+
+// A new scale identity can also change the existing target's legend family.
+// Keep the same transition validation/style policy used by in-place scale edits.
+export function withColorLegendReassignment(program, layer, scale, apply) {
+  const previous = findSemanticScale(program, layer.encoding?.color?.scale);
+  if (previous === undefined || previous.id === scale.id) return apply(program);
+  const plans = planColorLegendTransitions(program, previous, scale.type, { channel: "color", target: layer.id });
+  let next = program;
+  for (const plan of plans) next = next.removeLegend({ target: layer.id, channels: ["color"] });
+  next = apply(next);
+  for (const plan of plans) next = applyColorLegendTransition(next, plan);
+  return next;
+}

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

@@ -3,11 +3,12 @@ import { isPlainObject } from "../../../core/immutable.js";
 import { findSemanticScale } from "../../../selectors/scales.js";
 
 
-export function resolveDensityScaleOptions(value, defaults, label) {
+export function resolveDensityScaleOptions(value, defaults, label, program) {
   if (value !== undefined && !isPlainObject(value)) {
     throw new TypeError(`${label} must be a plain object.`);
   }
-  const scale = { ...defaults, ...(value ?? {}) };
+  const existing = program && value?.id ? findSemanticScale(program, value.id) : undefined;
+  const scale = { ...(existing ?? defaults), ...(value ?? {}) };
   if (value?.type === "log" && value.zero === undefined) delete scale.zero;
   return scale;
 }

package/src/actions/encodings/density.js

@@ -156,7 +156,7 @@ const encodeDensity = /* @__PURE__ */ action(
     const valueScale = resolveDensityScaleOptions(
       args.valueScale,
       { nice: false, zero: false },
-      "Density valueScale"
+      "Density valueScale", this
     );
     const placement = args.placement === undefined
       ? undefined
@@ -174,7 +174,7 @@ const encodeDensity = /* @__PURE__ */ action(
       ? resolveDensityScaleOptions(
           args.densityScale,
           { nice: true, zero: true },
-          "Density densityScale"
+          "Density densityScale", this
         )
       : undefined;
     const placementScale = placement === undefined

package/src/actions/encodings/offset.js

@@ -1,3 +1,4 @@
+import { assertIndependentOverlayGeometry } from "../../grammar/overlay.js";
 import { inferSeriesGroup } from "./shared.js";
 import { findSemanticScale } from "../../selectors/scales.js";
 import { action } from "../../core/action.js";
@@ -41,6 +42,7 @@ function createOffsetEncoding(channel) {
         ["bar", "point", "rule"],
         "offset-compatible mark"
       );
+      assertIndependentOverlayGeometry(layer, operation);
       const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
 
       if (layer.mark.type === "bar") {

package/src/actions/encodings/pathOrder.js

@@ -1,3 +1,4 @@
+import { assertIndependentOverlayGeometry } from "../../grammar/overlay.js";
 import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateNonEmptyString } from "../../core/validation.js";
@@ -86,6 +87,7 @@ const encodePathOrder = /* @__PURE__ */ closedAction(
     }
     const order = validatePathOrderDirection(args.order ?? "ascending");
     const layer = resolvePathOrderLayer(this, args.target);
+    assertIndependentOverlayGeometry(layer, "encodePathOrder");
     const dataset = assertPathOrderCompatible(this, layer, "encodePathOrder");
     readQuantitativeField(dataset.values, field);
 

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

@@ -0,0 +1,42 @@
+import { resolveTarget } from '../shared.js';
+import { findDataset, requireDataset } from '../../../selectors/datasets.js';
+
+// Completed-key data is tied to one independent coordinate. Its generated
+// rows are not observations and must never be reused as a different measure.
+export function rebindAlignedAreaPosition(program, channel, args) {
+  if (!['x', 'y'].includes(channel) || args.field === undefined ||
+      !program.semanticSpec.layers.some(layer => layer.mark.type === 'area')) return program;
+  const { layer } = resolveTarget(program, args.target, ['point', 'line', 'bar', 'area', 'rule', 'rect', 'text', 'tick']);
+  if (layer.mark.type !== 'area' || layer.encoding?.[`${channel}2`] ||
+      !layer.encoding?.[channel === 'x' ? 'y2' : 'x2']) return program;
+  const dataset = findDataset(program, layer.data);
+  const complete = dataset?.transform?.length === 1 && dataset.transform[0].type === 'complete' ? dataset.transform[0] : undefined;
+  if (!complete || complete.key !== layer.encoding[channel]?.field || args.field === complete.key) return program;
+  if (!layer.layout?.mode || layer.layout.mode === 'overlay') {
+    return program.rebindLayerData({ id: layer.id, data: dataset.source });
+  }
+  const measureChannel = channel === 'x' ? 'y' : 'x';
+  const measures = [layer.encoding[measureChannel]?.field, layer.encoding[`${measureChannel}2`]?.field].filter(Boolean);
+  if (measures.includes(args.field)) {
+    throw new Error('A stacked Area cannot use its measurement as the completed position key: generated rows need separate key and measurement fields. Choose another position field or Overlay layout.');
+  }
+  if (complete.groupBy.includes(args.field)) {
+    throw new Error('A stacked Area needs at least two positions within each series; its grouping field cannot also be the position key.');
+  }
+  const source = requireDataset(program, dataset.source);
+  const unique = new Set();
+  for (const row of source.values) {
+    const key = JSON.stringify([...complete.groupBy, args.field].map(field => row[field]));
+    if (unique.has(key)) throw new Error('The new Area position has duplicate rows within a series. Reaggregate the original observations at that grain before stacking, or use Overlay layout.');
+    unique.add(key);
+  }
+  const stem = `${layer.id}AlignedPosition`, ids = new Set(program.semanticSpec.datasets.map(data => data.id));
+  let id = stem;
+  for (let index = 2; ids.has(id); index++) id = `${stem}${index}`;
+  const fill = Object.fromEntries(Object.entries(complete.fill).filter(([field]) => field !== args.field));
+  let next = program.createCompleteData({ id, source: dataset.source, key: args.field, groupBy: complete.groupBy, fill });
+  next = next.rebindLayerData({ id: layer.id, data: id });
+  return next._withMarkConfig(layer.id, { ...next.markConfigs[layer.id], alignedPositionData: [
+    id, ...(next.markConfigs[layer.id]?.alignedPositionData ?? [])
+  ] });
+}

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

@@ -1,3 +1,5 @@
+import { rebindAlignedAreaPosition } from './areaAlignment.js';
+import { assertSharedPositionMeaning } from '../../../selectors/plotComposition.js';
 import { stackLayoutMode } from "../seriesLayout.js";
 import { resolveBarGrain } from "../../../grammar/bars/policy.js";
 import { action } from "../../../core/action.js";
@@ -9,12 +11,31 @@ import { findLayer } from "../../../selectors/layers.js";
 import { findSemanticScale } from "../../../selectors/scales.js";
 import { applyPositionSemantics } from "./apply.js";
 import {
+  resolveTarget,
   applyEncodingScale,
   applyDetachedScaleRematerialization,
   rebindPositionGuides
 } from "../shared.js";
 
 function encodePosition(program, channel, args, operation) {
+  program = rebindAlignedAreaPosition(program, channel, args);
+  if (channel === 'theta' && typeof program.encodeChannels === 'function') {
+    const { layer } = resolveTarget(program, args.target, ['arc', 'line', 'point']);
+    const old = layer.encoding?.theta, color = layer.encoding?.color;
+    const scale = findSemanticScale(program, layer.encoding?.radius?.scale);
+    if (layer.mark.type === 'arc' && scale?.radialMapping && old?.field &&
+        args.field !== old.field && color?.field === old.field &&
+        ['nominal', 'ordinal'].includes(args.fieldType ?? old.fieldType)) {
+      const { target: _target, coordinate, ...theta } = args;
+      if (coordinate !== undefined && coordinate !== layer.coordinate) {
+        throw new Error('encodeTheta cannot move a measured polar mark to a different coordinate.');
+      }
+      return program.editSemantic({ property: `layer[${layer.id}].encoding.color.field`, value: args.field })
+        .encodeChannels({ target: layer.id, channels: {
+        theta, color: { field: args.field, fieldType: args.fieldType ?? old.fieldType }
+      } });
+    }
+  }
   const {
     target,
     layer,
@@ -34,9 +55,22 @@ function encodePosition(program, channel, args, operation) {
     companion,
     clearRadialMapping
   } = resolvePositionEncoding(program, channel, args, operation);
+  if (layer.derivedBindings?.overlay) throw new Error("Overlay position follows its source; edit the source or detach the overlay first.");
 
-  let next = program
-    .createCoordinate({
+  if (args.scale?.id === undefined) assertSharedPositionMeaning(program, layer, channel, {
+    ...(hasField ? { field } : { datum }), fieldType, temporalUnit,
+    scale: scale.id, aggregate, bin, stack
+  });
+  let next = program;
+  if (previous?.field !== undefined && previous.field !== field && ['theta', 'radius'].includes(channel)) {
+    for (const [id, config] of Object.entries(next.guideConfigs.axis ?? {})) {
+      for (const part of ['ticks', 'labels']) {
+        if (config[part]?.scale !== previous.scale || config[part].mode !== 'values') continue;
+        next = next._withGuideConfig(id, part, { ...config[part], inferredValues: true });
+      }
+    }
+  }
+  next = next.createCoordinate({
       id: coordinate.id,
       type: coordinate.type,
       layers: [target]
@@ -70,7 +104,7 @@ function encodePosition(program, channel, args, operation) {
   }
   next = applyEncodingScale(next, scale, requestedScale, {
     reassignment: previous?.scale === scale.id,
-    allowTypeChange: layer.mark.type === "area"
+    allowTypeChange: layer.mark.type === "area" || previous?.field === field && previous?.fieldType === fieldType
   });
   if (["bar", "area"].includes(layer.mark.type) && Object.hasOwn(args, "stack") && args.stack !== undefined) {
     next = next.editSemantic({ property: `layer[${target}].layout.mode`, value: stackLayoutMode(args.stack) });

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

@@ -1 +1 @@
-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};
+import{validateAggregate as L,validateAggregateFieldType as P}from"../../../../grammar/aggregate.js";import{emptyPositionPolicy as g,resolveBin as k}from"./common.js";import{findSemanticScale as A}from"../../../../selectors/scales.js";import{validateCategoricalColorConsumer as C}from"../../../../grammar/scales/colorConsumers.js";import{validateLineMissingScope as B}from"../../../../grammar/lineMissing.js";import{isAggregateLinePosition as v,isHorizontalLine as D}from"../../../../grammar/lineSeries.js";function f(r,e){if(r.stack!==void 0)throw new Error(`Line ${e} encoding does not support stack.`)}function q(r,e){if(r.bin!==void 0)throw new Error(`Line ${e} encoding does not support bin.`)}function S({program:r,layer:e,dataset:a,channel:t,args:n,fieldType:i,orientationNormalized:l=!1}){B({...e,encoding:{...e.encoding,[t]:{...n,fieldType:i}}});for(const o of["color","strokeDash"]){const d=e.encoding?.[o],c=d===void 0?void 0:A(r,d.scale);c!==void 0&&C({...e,encoding:{...e.encoding,[t]:{...e.encoding[t],...n,fieldType:i}}},d,c,o)}const x=["theta","radius"].includes(t),u=r.markConfigs[e.id]??{};if(x){if(u.curve!==void 0&&u.curve!=="linear")throw new Error('Polar line position currently requires curve "linear".');if(q(n,t),f(n,t),n.aggregate!==void 0)throw new Error(`Line ${t} encoding does not support aggregate.`);return g()}if(u.closed===!0)throw new Error("Line closed requires theta/radius Polar position encodings.");const s={...e,encoding:{...e.encoding,[t]:{...n,fieldType:i}}};if(s.encoding.x?.aggregate!==void 0&&s.encoding.y?.aggregate!==void 0)throw new Error("A Line requires one independent position; both axes cannot aggregate.");if(!l&&D(s))return S({program:r,dataset:a,layer:{...e,encoding:{...e.encoding,x:e.encoding?.y,y:e.encoding?.x}},channel:t==="x"?"y":"x",args:n,fieldType:i,orientationNormalized:!0});const w=a.transform?.some(o=>o.type==="regression"),m=a.transform?.some(o=>o.type==="interval"),E=a.transform?.some(o=>o.type==="window"&&o.operations?.some(d=>d.as===n.field));if(t==="x"){if(f(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:k(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 g()}const o=e.encoding?.y?.aggregate===void 0&&["quantitative","temporal"].includes(e.encoding?.y?.fieldType)&&i==="quantitative",d=e.encoding?.y===void 0&&i==="quantitative",c=e.encoding?.y?.aggregate!==void 0&&v({fieldType:i});if(i!=="temporal"&&!((w||m||o||d||c)&&i==="quantitative"))throw new Error("Line x encoding requires a categorical or temporal field, or a compatible quantitative field.");return g()}if(q(n,"y"),f(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 h=i==="quantitative"&&["quantitative","temporal","nominal","ordinal"].includes(e.encoding?.x?.fieldType)&&e.encoding.x.bin===void 0,b=n.aggregate===void 0&&(i==="temporal"||i==="quantitative"&&(e.encoding?.x===void 0||h));if(m||E&&n.aggregate===void 0||b){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 g()}if(w){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 g()}if(e.encoding?.x!==void 0&&!v(e.encoding.x))throw new Error("Aggregate line y encoding requires a quantitative, temporal, or categorical x encoding.");const p=L(n.aggregate);return P(p,i),{bin:void 0,aggregate:p,stack:void 0}}export{S as resolveLinePositionPolicy};

package/src/actions/encodings/ranged.js

@@ -1,3 +1,4 @@
+import { assertIndependentOverlayGeometry } from "../../grammar/overlay.js";
 import { readAreaEndpoint, validateAreaEndpointPair, normalizeAreaBound } from "../../grammar/areaEndpoints.js";
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
@@ -83,11 +84,11 @@ function encodeSecondaryPosition(program, channel, args, operation, types) {
   if (!rule && !area && !rect && (!hasField || hasDatum)) {
     throw new Error(`${operation} requires a field for a ranged mark.`);
   }
-  if (rule && args.fieldType === undefined) {
+  if (rule && hasField && args.fieldType === undefined) {
     throw new Error(`${operation} requires fieldType for a rule mark.`);
   }
   const fieldType = rule
-    ? validateSemanticFieldType(args.fieldType)
+    ? validateSemanticFieldType(args.fieldType ?? "quantitative")
     : layer.mark.type === "rect"
       ? args.fieldType ?? primary.fieldType
       : args.fieldType ?? "quantitative";
@@ -306,6 +307,7 @@ const encodeGroup = /* @__PURE__ */ action(
       ["line", "area", "bar"],
       "series mark"
     );
+    assertIndependentOverlayGeometry(layer, "encodeGroup");
     if ((args.fieldType ?? "nominal") !== "nominal") {
       throw new Error("encodeGroup requires a nominal field.");
     }

package/src/actions/encodings/remove.js

@@ -1,3 +1,4 @@
+import {legendBlockChannels} from "../../grammar/legendBlocks.js";
 import { cartesianAxisOwners, axisTargetArgs } from "../../selectors/axes.js";
 import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
@@ -41,13 +42,7 @@ const REMOVE_AXIS = Object.freeze({
   theta: "removeThetaAxis",
   radius: "removeRadialAxis"
 });
-const SPECIALIZED_LEGEND_KIND = Object.freeze({
-  color: Object.freeze(["gradient", "interval", "colorSize"]),
-  stroke: Object.freeze(["strokeGradient", "strokeInterval"]),
-  size: Object.freeze(["size", "colorSize"]),
-  opacity: Object.freeze(["opacity"]),
-  strokeWidth: Object.freeze(["strokeWidth"])
-});
+
 
 function resolveTarget(program, requested, channel) {
   const candidates = program.semanticSpec.layers.filter(
@@ -190,9 +185,10 @@ function reconcileCategoricalLegend(program, target, channels) {
 
 function cleanupLegends(program, target, channels) {
   let next = reconcileCategoricalLegend(program, target, channels);
-  const kinds = [...new Set(channels.flatMap(
-    channel => SPECIALIZED_LEGEND_KIND[channel] ?? []
-  ))].filter(kind => next.guideConfigs.legend?.[kind]?.target === target);
+  const kinds = Object.entries(next.guideConfigs.legend ?? {})
+    .filter(([kind, config]) => !["series", "color", "stroke"].includes(kind) &&
+      config.target === target && legendBlockChannels(kind, config).some(channel => channels.includes(channel)))
+    .map(([kind]) => kind);
   return kinds.length === 0 ? next : removeLegendKinds(next, kinds);
 }
 
@@ -221,6 +217,9 @@ export const removeEncoding = /* @__PURE__ */ closedAction(
       );
     }
     const layer = resolveTarget(this, args.target, args.channel);
+    if (layer.derivedBindings?.overlay && ["x", "y", "x2", "y2", "xOffset", "yOffset", "group", "pathOrder"].includes(args.channel)) {
+      throw new Error("Overlay geometry follows its source; edit the source or detach the overlay first.");
+    }
     if (args.channel === "group" && layer.layout?.mode !== undefined && layer.layout.mode !== "overlay") throw new Error("Remove active series layout before removing its group.");
     if (args.channel === "theta" && layer.mark.type === "arc" &&
       ["count", "sum"].includes(layer.encoding?.radius?.aggregate)) {
@@ -254,6 +253,10 @@ export const removeEncoding = /* @__PURE__ */ closedAction(
       .filter(item => item.scale !== undefined);
 
     let next = this;
+    if (args.channel === "color" && layer.derivedBindings?.overlay?.inheritColor) {
+      next = next.editSemantic({ property: `layer[${layer.id}].derivedBindings.overlay`,
+        value: { ...layer.derivedBindings.overlay, inheritColor: false } });
+    }
     for (const channel of channels) {
       next = next.editSemantic({
         property: `layer[${layer.id}].encoding.${channel}`,

package/src/actions/encodings/ruleAppearance.js

@@ -1,4 +1,4 @@
-import { APPEARANCE_MARK_TYPES } from "../../core/vocabulary.js";
+import { APPEARANCE_MARK_TYPES, FIXED_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";
@@ -39,8 +39,20 @@ 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, APPEARANCE_MARK_TYPES.encodeStrokeWidth, "rule, line or rect mark");
+      const { id, layer } = resolveTarget(this, args.target, FIXED_APPEARANCE_MARK_TYPES.encodeStrokeWidth, "stroked mark");
       assertEncodingSelectionCompatibility(this, id, ["strokeWidth"]);
+      if (!APPEARANCE_MARK_TYPES.encodeStrokeWidth.includes(layer.mark.type)) {
+        const config = { ...this.markConfigs[id] };
+        const appearance = layer.mark.type === "bar" ? { ...config.barAppearance } : config;
+        // Width authoring enables an absent outline; existing constant or
+        // field-driven strokes keep their color and scale ownership.
+        const needsStroke = !layer.encoding?.stroke && (appearance.stroke === false ||
+          (["point", "area"].includes(layer.mark.type) && appearance.stroke === undefined));
+        if (needsStroke) appearance.stroke = "#000000";
+        appearance.strokeWidth = args.value;
+        if (layer.mark.type === "bar") config.barAppearance = appearance;
+        return rematerializeEncoding(this._withMarkConfig(id, config), id, "strokeWidth", undefined, layer);
+      }
       let next = this.guideConfigs.legend?.strokeWidth?.target === id
         ? this.removeLegend({ target: id, channels: ["strokeWidth"] })
         : this;