ggaction 0.0.18 → 0.0.20

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

@@ -1,190 +1 @@
-import {
-  deriveCenteredAreaSeries,
-  deriveAreaSeries,
-  deriveDensityAreaSeries,
-  layoutDensityAreaSeries
-} from "../../../grammar/areaSeries.js";
-import {
-  mapContinuousScaleValues,
-  mapOrdinalPositionValues,
-  mapOrdinalValues
-} from "../../../grammar/scales/index.js";
-import { mapScaleConsumerValues } from
-  "../../../materialization/scales/map.js";
-import { buildAreaCurvePathCommands } from
-  "../../../grammar/curveCommands.js";
-import { buildLinearPathCommands } from
-  "../../../grammar/pathCommands.js";
-import { buildCategoricalDensityPaths } from
-  "../../../grammar/categoricalDensity.js";
-import { derivePathSeriesFieldValues } from "../../../grammar/pathSeries.js";
-
-function resolveAreaPaths({
-  derived,
-  densityTransform,
-  categoricalDensity,
-  xScale,
-  yScale,
-  densityScale,
-  layout,
-  curve
-}) {
-  if (categoricalDensity) {
-    return buildCategoricalDensityPaths(derived, {
-      categoryScale: densityTransform.placement.channel === "x" ? xScale : yScale,
-      valueScale: densityTransform.placement.channel === "x" ? yScale : xScale,
-      curve
-    });
-  }
-  return derived.series.map(series => {
-    if (densityTransform === undefined && derived.orientation === "horizontal") {
-      const y = (["point", "band"].includes(yScale.type) ? mapOrdinalPositionValues : mapContinuousScaleValues)(
-        series.values.map(value => value.y), yScale
-      );
-      const lower = mapContinuousScaleValues(
-        series.values.map(value => value.x),
-        xScale
-      );
-      const upper = mapContinuousScaleValues(
-        series.values.map(value => value.x2),
-        xScale
-      );
-      return buildAreaCurvePathCommands(
-        y.map((value, index) => ({ x: lower[index], y: value })),
-        y.map((value, index) => ({ x: upper[index], y: value })),
-        curve,
-        { independentAxis: "y" }
-      );
-    }
-    if (densityTransform !== undefined && derived.mode === "x-density") {
-      const y = (["point", "band"].includes(yScale.type) ? mapOrdinalPositionValues : mapContinuousScaleValues)(
-        series.values.map(value => value.y), yScale
-      );
-      const upper = mapContinuousScaleValues(
-        series.values.map(value => value.x),
-        xScale
-      );
-      const baseline = mapContinuousScaleValues([0], densityScale)[0];
-      if (curve === "linear") {
-        return buildLinearPathCommands([
-          { x: baseline, y: y[0] },
-          ...y.map((value, index) => ({ x: upper[index], y: value })),
-          { x: baseline, y: y.at(-1) }
-        ], { close: true });
-      }
-      return buildAreaCurvePathCommands(
-        y.map(value => ({ x: baseline, y: value })),
-        y.map((value, index) => ({ x: upper[index], y: value })),
-        curve,
-        { independentAxis: "y" }
-      );
-    }
-    const x = (["point", "band"].includes(xScale.type) ? mapOrdinalPositionValues : mapContinuousScaleValues)(
-      series.values.map(value => value.x),
-      xScale
-    );
-    const lowerValues = densityTransform === undefined
-      ? derived.mode === "y-center"
-        ? series.values.map(value => value.lower)
-        : series.values.map(value => value.y)
-      : derived.mode === "y-density"
-        ? series.values.map(value => value.lower)
-        : series.values.map(value => value.y);
-    const lower = mapContinuousScaleValues(lowerValues, yScale);
-    const upperValues = densityTransform === undefined
-      ? derived.mode === "y-center"
-        ? series.values.map(value => value.upper)
-        : series.values.map(value => value.y2)
-      : series.values.map(value => value.upper);
-    const upper = mapContinuousScaleValues(upperValues, yScale);
-    if (densityTransform !== undefined && layout === "overlay") {
-      const baseline = mapContinuousScaleValues([0], yScale)[0];
-      if (curve === "linear") {
-        return buildLinearPathCommands([
-          { x: x[0], y: baseline },
-          ...x.map((value, index) => ({ x: value, y: upper[index] })),
-          { x: x.at(-1), y: baseline }
-        ], { close: true });
-      }
-      return buildAreaCurvePathCommands(
-        x.map(value => ({ x: value, y: baseline })),
-        x.map((value, index) => ({ x: value, y: upper[index] })),
-        curve
-      );
-    }
-    return buildAreaCurvePathCommands(
-      x.map((value, index) => ({ x: value, y: lower[index] })),
-      x.map((value, index) => ({ x: value, y: upper[index] })),
-      curve
-    );
-  });
-}
-
-export function resolveAreaMaterialization({
-  rows,
-  layer,
-  densityTransform,
-  resolvedScales,
-  config
-}) {
-  const xScale = resolvedScales[layer.encoding.x.scale];
-  const yScale = resolvedScales[layer.encoding.y.scale];
-  const centered = densityTransform === undefined &&
-    layer.encoding?.y?.stack === "center";
-  const rawDerived = densityTransform === undefined
-    ? centered
-      ? deriveCenteredAreaSeries(rows, layer, { xDomain: xScale.domain })
-      : deriveAreaSeries(rows, layer, { xDomain: xScale.domain, yDomain: yScale.domain })
-    : deriveDensityAreaSeries(rows, layer, densityTransform);
-  const colorEncoding = layer.encoding?.color;
-  const layout = layer.layout?.mode ?? colorEncoding?.layout ?? "overlay";
-  const categoricalDensity = densityTransform?.placement?.type === "category";
-  const derived = densityTransform === undefined || categoricalDensity
-    ? rawDerived
-    : layoutDensityAreaSeries(rawDerived, layout);
-  const densityScale = densityTransform === undefined || categoricalDensity
-    ? undefined
-    : derived.mode === "y-density" ? yScale : xScale;
-  if (
-    densityScale !== undefined &&
-    (densityScale.domain[0] > 0 || densityScale.domain[1] < 0)
-  ) {
-    throw new Error(`Density area mark "${layer.id}" requires a scale domain containing zero.`);
-  }
-  const paths = resolveAreaPaths({
-    derived,
-    densityTransform,
-    categoricalDensity,
-    xScale,
-    yScale,
-    densityScale,
-    layout,
-    curve: config.curve ?? "linear"
-  });
-  const fills = config.errorBand?.fill !== undefined
-    ? paths.map(() => config.errorBand.fill)
-    : colorEncoding?.scale === undefined
-      ? paths.map(() => config.fill)
-      : mapOrdinalValues(
-          densityTransform !== undefined || centered
-            ? derived.series.map(series => series.key[colorEncoding.field])
-            : derivePathSeriesFieldValues(rows, derived.series, colorEncoding.field, "color"),
-          resolvedScales[colorEncoding.scale].domain,
-          resolvedScales[colorEncoding.scale].range
-        );
-  const strokeEncoding = layer.encoding?.stroke;
-  const strokes = strokeEncoding?.scale === undefined
-    ? undefined
-    : mapScaleConsumerValues(
-        derivePathSeriesFieldValues(
-          rows,
-          derived.series,
-          strokeEncoding.field,
-          "stroke",
-          strokeEncoding
-        ),
-        resolvedScales[strokeEncoding.scale],
-        "stroke"
-      );
-  return { paths, fills, strokes };
-}
+import{deriveCenteredAreaSeries as P,deriveAreaSeries as V,deriveDensityAreaSeries as w,layoutDensityAreaSeries as z}from"../../../grammar/areaSeries.js";import{mapContinuousScaleValues as c,mapOrdinalPositionValues as D}from"../../../grammar/scales/index.js";import{mapScaleConsumerValues as b}from"../../../materialization/scales/map.js";import{buildAreaCurvePathCommands as A}from"../../../grammar/curveCommands.js";import{buildLinearPathCommands as k}from"../../../grammar/pathCommands.js";import{buildCategoricalDensityPaths as E}from"../../../grammar/categoricalDensity.js";import{derivePathSeriesFieldValues as C}from"../../../grammar/pathSeries.js";function q({derived:d,densityTransform:a,categoricalDensity:m,xScale:l,yScale:u,densityScale:x,layout:v,curve:r}){return m?E(d,{categoryScale:a.placement.channel==="x"?l:u,valueScale:a.placement.channel==="x"?u:l,curve:r}):d.series.map(o=>{if(a===void 0&&d.orientation==="horizontal"){const e=(["point","band"].includes(u.type)?D:c)(o.values.map(n=>n.y),u),t=c(o.values.map(n=>n.x),l),p=c(o.values.map(n=>n.x2),l);return A(e.map((n,s)=>({x:t[s],y:n})),e.map((n,s)=>({x:p[s],y:n})),r,{independentAxis:"y"})}if(a!==void 0&&d.mode==="x-density"){const e=(["point","band"].includes(u.type)?D:c)(o.values.map(n=>n.y),u),t=c(o.values.map(n=>n.x),l),p=c([0],x)[0];return r==="linear"?k([{x:p,y:e[0]},...e.map((n,s)=>({x:t[s],y:n})),{x:p,y:e.at(-1)}],{close:!0}):A(e.map(n=>({x:p,y:n})),e.map((n,s)=>({x:t[s],y:n})),r,{independentAxis:"y"})}const i=(["point","band"].includes(l.type)?D:c)(o.values.map(e=>e.x),l),g=a===void 0?d.mode==="y-center"?o.values.map(e=>e.lower):o.values.map(e=>e.y):d.mode==="y-density"?o.values.map(e=>e.lower):o.values.map(e=>e.y),h=c(g,u),y=a===void 0?d.mode==="y-center"?o.values.map(e=>e.upper):o.values.map(e=>e.y2):o.values.map(e=>e.upper),f=c(y,u);if(a!==void 0&&v==="overlay"){const e=c([0],u)[0];return r==="linear"?k([{x:i[0],y:e},...i.map((t,p)=>({x:t,y:f[p]})),{x:i.at(-1),y:e}],{close:!0}):A(i.map(t=>({x:t,y:e})),i.map((t,p)=>({x:t,y:f[p]})),r)}return A(i.map((e,t)=>({x:e,y:h[t]})),i.map((e,t)=>({x:e,y:f[t]})),r)})}function G({rows:d,layer:a,densityTransform:m,resolvedScales:l,config:u}){const x=l[a.encoding.x.scale],v=l[a.encoding.y.scale],r=m===void 0&&a.encoding?.y?.stack==="center",o=m===void 0?r?P(d,a,{xDomain:x.domain}):V(d,a,{xDomain:x.domain,yDomain:v.domain}):w(d,a,m),i=a.encoding?.color,g=a.layout?.mode??i?.layout??"overlay",h=m?.placement?.type==="category",y=m===void 0||h?o:z(o,g),f=m===void 0||h?void 0:y.mode==="y-density"?v:x;if(f!==void 0&&(f.domain[0]>0||f.domain[1]<0))throw new Error(`Density area mark "${a.id}" requires a scale domain containing zero.`);const e=q({derived:y,densityTransform:m,categoricalDensity:h,xScale:x,yScale:v,densityScale:f,layout:g,curve:u.curve??"linear"}),t=u.errorBand?.fill!==void 0?e.map(()=>u.errorBand.fill):i?.scale===void 0?e.map(()=>u.fill):b(i.fieldType!=="quantitative"&&(m!==void 0||r)?y.series.map(s=>s.key[i.field]):C(d,y.series,i.field,"color",i),l[i.scale],"color"),p=a.encoding?.stroke,n=p?.scale===void 0?void 0:b(C(d,y.series,p.field,"stroke",p),l[p.scale],"stroke");return{paths:e,fills:t,strokes:n}}export{G as resolveAreaMaterialization};

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

@@ -18,20 +18,20 @@ import { validateFillPaint } from "../../../grammar/paint.js";
 import { validateItemMissing } from "../../../grammar/itemMissing.js";
 
 const EDIT_OPTIONS = Object.freeze([
-  "target", "missing", "fill", "opacity", "stroke", "strokeWidth", ...RECT_RADIUS_PROPERTIES,
+  "target", "missing", "blend", "fill", "opacity", "stroke", "strokeWidth", ...RECT_RADIUS_PROPERTIES,
   ...STROKE_STYLE_PROPERTIES
 ]);
 
 export const editBarMark = /* @__PURE__ */ action(
   {
     op: "editBarMark",
-    description: "Edit whole-bar fill, opacity, and outline appearance."
+    description: "Edit whole-bar fill, opacity, outline, and compositing appearance."
   },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editBarMark");
     const styleDetails = requestedRectStyleDetails(args, "editBarMark");
     const changes = [
-      "missing", "fill", "opacity", "stroke", "strokeWidth", ...RECT_RADIUS_PROPERTIES,
+      "missing", "blend", "fill", "opacity", "stroke", "strokeWidth", ...RECT_RADIUS_PROPERTIES,
       ...STROKE_STYLE_PROPERTIES
     ];
     if (!changes.some(key => Object.hasOwn(args, key))) {
@@ -66,13 +66,12 @@ export const editBarMark = /* @__PURE__ */ action(
       );
     }
 
-    const semantic = Object.hasOwn(args, "missing")
-      ? this.editSemantic({
-          property: `layer[${layer.id}].mark.missing`,
-          value: validateItemMissing(args.missing, "Bar missing")
-        })
-      : this;
-    const config = { ...semantic.markConfigs[layer.id] };
+    if (Object.hasOwn(args, "blend") && !["normal", "difference"].includes(args.blend)) {
+      throw new Error("Bar blend must be normal or difference.");
+    }
+    const missing = Object.hasOwn(args, "missing")
+      ? validateItemMissing(args.missing, "Bar missing") : undefined;
+    const config = { ...this.markConfigs[layer.id] };
     const appearance = { ...config.barAppearance };
     Object.assign(appearance, styleDetails);
     if (Object.hasOwn(args, "fill")) {
@@ -106,10 +105,22 @@ export const editBarMark = /* @__PURE__ */ action(
       );
     }
 
-    const next = semantic._withMarkConfig(layer.id, {
+    let semantic = missing === undefined ? this : this.editSemantic({
+      property: `layer[${layer.id}].mark.missing`, value: missing
+    });
+    if (Object.hasOwn(args, "blend")) {
+      if (args.blend === "difference") {
+        semantic = semantic.editSemantic({property: `layer[${layer.id}].mark.blend`, value: "difference"});
+      } else if (layer.mark.blend !== undefined) {
+        semantic = semantic.editSemantic({property: `layer[${layer.id}].mark.blend`, remove: true});
+      }
+    }
+    const editsAppearance = changes.some(key => key !== "missing" && key !== "blend" &&
+      Object.hasOwn(args, key));
+    const next = editsAppearance ? semantic._withMarkConfig(layer.id, {
       ...config,
       barAppearance: appearance
-    });
+    }) : semantic;
     const materialized = canMaterializeBar(next, layer)
       ? next.rematerializeBarMark({ id: layer.id })
       : next;

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

@@ -1,3 +1,4 @@
+import { findLayer } from "../../../selectors/layers.js";
 import { editGraphicProperties } from "../../primitives/graphicProperties.js";
 import { action } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
@@ -20,9 +21,13 @@ const REMATERIALIZE_OPTIONS = Object.freeze(["id", "scales"]);
 
 function editRectangles(program, id, rectangles) {
   const appearance = program.markConfigs[id]?.barAppearance ?? {};
+  const blend = findLayer(program, id)?.mark?.blend;
+  if (blend !== undefined) rectangles = rectangles.map(rect => ({...rect, blend}));
   const hasShapeStyle = RECT_STYLE_PROPERTIES
     .some(property => Object.hasOwn(appearance, property));
-  if (hasShapeStyle) {
+  const previousBlend = program.graphicSpec.objects[id]?.items?.some(item =>
+    item.properties?.blend !== undefined);
+  if (hasShapeStyle || blend !== undefined || previousBlend) {
     const radius = appearance;
     return replaceGraphicItems(
       program,

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

@@ -1,3 +1,4 @@
+import { validateGraphicItemLimit } from "../../../core/validation.js";
 import { editGraphicProperties } from "../../primitives/graphicProperties.js";
 import { action } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
@@ -29,6 +30,8 @@ import {
 } from "../../../theme/defaults.js";
 import { findDataset } from "../../../selectors/datasets.js";
 import { findLayer } from "../../../selectors/layers.js";
+import { resolveGraphicItemCapacity } from "../../../selectors/graphicCapacity.js";
+import { getMarkGraphicTypes } from "../../../core/vocabulary.js";
 import { canMaterializePoint } from "../../../materialization/marks/capabilities.js";
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
 import {
@@ -335,13 +338,14 @@ export const rematerializePointMark = /* @__PURE__ */ action(
     if (layer?.mark?.type !== "point") {
       throw new Error(`Unknown point mark "${id}".`);
     }
-    if (!["circle", "rect", "path", "collection"].includes(graphic?.type)) {
+    if (!getMarkGraphicTypes("point").includes(graphic?.type)) {
       throw new Error(`Point mark "${id}" requires point graphics.`);
     }
     const sourceDataset = findDataset(resolved, layer.data);
     if (sourceDataset === undefined) {
       throw new Error(`Point mark "${id}" requires an existing dataset.`);
     }
+    validateGraphicItemLimit(sourceDataset.values.length, resolveGraphicItemCapacity(resolved, { id, label: "Point mark item count" }));
     const dataset = applyItemMissingPolicy(layer, sourceDataset);
 
     if (graphic.items.length === 0 && !canMaterializePoint(resolved, layer)) {

package/src/actions/marks/remove.js

@@ -1,3 +1,4 @@
+import { cartesianAxisOwners, axisTargetArgs } from "../../selectors/axes.js";
 import { ownedChildren, ownership } from "../../selectors/markOwners.js";
 import { isSourceOwnedText } from "../../grammar/text.js";
 import { closedAction } from "../../core/action.js";
@@ -183,16 +184,15 @@ function cleanupPositionGuides(program, scales) {
   let next = program;
   for (const channel of POSITION_CHANNELS) {
     const definition = getPositionChannelDefinition(channel);
-    const axis = next.semanticSpec.guides.axis?.[channel];
-    if (
-      axis !== undefined &&
-      scales[channel].has(axis.scale) &&
-      !hasScaleConsumer(next, channel, axis.scale)
-    ) {
-      next = next[REMOVE_AXIS[channel]]({
-        scale: axis.scale,
-        ...(axis.coordinate === undefined ? {} : { coordinate: axis.coordinate })
-      });
+    const owners = ["x", "y"].includes(channel)
+      ? cartesianAxisOwners(next).filter(owner => owner.channel === channel)
+      : [{ id: channel, channel, semantic: next.semanticSpec.guides.axis?.[channel] }];
+    for (const owner of owners) {
+      const axis = owner.semantic;
+      if (axis !== undefined && scales[channel].has(axis.scale) && !hasScaleConsumer(next, channel, axis.scale)) {
+        next = next[REMOVE_AXIS[channel]]({ ...axisTargetArgs(owner.id, channel), scale: axis.scale,
+          ...(axis.coordinate === undefined ? {} : { coordinate: axis.coordinate }) });
+      }
     }
     const grid = next.semanticSpec.guides.grid?.[definition.gridDirection];
     if (

package/src/actions/primitives/createGraphics.js

@@ -1,7 +1,8 @@
+import { validateGraphicItemLimit } from "../../core/validation.js";
 import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { freezeOwned } from "../../core/immutable.js";
-import { validateGeneratedItemLimit } from "../../core/validation.js";
+import { resolveGraphicItemCapacity } from "../../selectors/graphicCapacity.js";
 import {
   isDrawableGraphicType,
   isGraphicContainerType,
@@ -118,7 +119,7 @@ const createGraphics = /* @__PURE__ */ closedAction(
       throw new TypeError("createGraphics length must be a non-negative integer.");
     }
     if (length !== undefined) {
-      validateGeneratedItemLimit(length, "createGraphics length");
+      validateGraphicItemLimit(length, resolveGraphicItemCapacity(this, { id, label: "createGraphics length", type: validatedType }));
     }
     if (validatedType === "collection" && length !== undefined) {
       throw new Error("Heterogeneous collections use editGraphics items instead of length.");

package/src/actions/primitives/editGraphics.js

@@ -1,6 +1,7 @@
+import { validateGraphicItemLimit } from "../../core/validation.js";
 import { closedAction } from "../../core/action.js";
 import { cloneAndFreeze, freezeOwned, isPlainObject } from "../../core/immutable.js";
-import { validateGeneratedItemLimit } from "../../core/validation.js";
+import { resolveGraphicItemCapacity } from "../../selectors/graphicCapacity.js";
 import {
   isPrimitiveDrawableGraphicType,
   isStructuralGraphicType,
@@ -43,14 +44,14 @@ function validateCollectionItem(item, ownerId, index) {
   });
 }
 
-function replaceCollectionItems(value, id) {
+function replaceCollectionItems(value, id, program) {
   if (!Array.isArray(value)) throw new TypeError("collection.items must be an array.");
-  validateGeneratedItemLimit(value.length, "collection.items length");
+  validateGraphicItemLimit(value.length, resolveGraphicItemCapacity(program, { id, label: "collection.items length" }));
   return freezeOwned(value.map((item, index) => validateCollectionItem(item, id, index)));
 }
 
-function replaceDrawableItems(value, id, type) {
-  const items = replaceCollectionItems(value, id);
+function replaceDrawableItems(value, id, type, program) {
+  const items = replaceCollectionItems(value, id, program);
   if (!items.every(item => item.type === type)) {
     return freezeOwned({ type: "collection", items });
   }
@@ -102,15 +103,15 @@ function editGeneratedItem(owner, itemIndex, property, value) {
   return freezeOwned({ ...owner, items: freezeOwned(items) });
 }
 
-function editItems(owner, property, value, id) {
+function editItems(owner, property, value, id, program) {
   if (owner.type === "collection" && property === "items") {
-    return freezeOwned({ ...owner, items: replaceCollectionItems(value, id) });
+    return freezeOwned({ ...owner, items: replaceCollectionItems(value, id, program) });
   }
   if (property === "length") {
     if (!Number.isInteger(value) || value < 0) {
       throw new TypeError("Graphic collection length must be a non-negative integer.");
     }
-    validateGeneratedItemLimit(value, "Graphic collection length");
+    validateGraphicItemLimit(value, resolveGraphicItemCapacity(program, { id, label: "Graphic collection length" }));
     const items = owner.items.slice(0, value);
     for (let index = items.length; index < value; index += 1) {
       if (owner.type === "collection") {
@@ -189,6 +190,9 @@ const editGraphics = /* @__PURE__ */ closedAction(
 
     const ownerId = found.kind === "item" ? found.ownerId : found.id;
     const owner = found.kind === "item" ? found.owner : found.object;
+    if (owner.items !== undefined) validateGraphicItemLimit(owner.items.length, resolveGraphicItemCapacity(this, {
+      id: ownerId, label: "Graphic collection length"
+    }));
     const replacesDrawableItems =
       found.kind === "object" && property === "items" &&
       owner.items !== undefined && owner.type !== "collection";
@@ -199,7 +203,7 @@ const editGraphics = /* @__PURE__ */ closedAction(
           : owner.type, property);
     let updated;
     if (replacesDrawableItems) {
-      updated = replaceDrawableItems(value, ownerId, owner.type);
+      updated = replaceDrawableItems(value, ownerId, owner.type, this);
     } else if (found.kind === "item") {
       if (validatedProperty === "length" || validatedProperty === "items") {
         throw new Error(`${validatedProperty} can only target an owning graphic.`);
@@ -212,12 +216,12 @@ const editGraphics = /* @__PURE__ */ closedAction(
         properties: setGraphicProperty(owner.properties, validatedProperty, value)
       });
     } else if (owner.items !== undefined) {
-      updated = editItems(owner, validatedProperty, value, ownerId);
+      updated = editItems(owner, validatedProperty, value, ownerId, this);
     } else if (validatedProperty === "length") {
       if (!Number.isInteger(value) || value < 0) {
         throw new TypeError("Graphic collection length must be a non-negative integer.");
       }
-      validateGeneratedItemLimit(value, "Graphic collection length");
+      validateGraphicItemLimit(value, resolveGraphicItemCapacity(this, { id: ownerId, label: "Graphic collection length" }));
       updated = freezeOwned({
         type: owner.type,
         items: freezeOwned(Array.from({ length: value }, (_, index) => freezeOwned({

package/src/actions/primitives/graphicProperties.js

@@ -1,6 +1 @@
-export function editGraphicProperties(program, target, properties) {
-  for (const [property, value] of Object.entries(properties)) {
-    program = program.editGraphics({ target, property, value });
-  }
-  return program;
-}
+export { editGraphicProperties } from "../../core/graphicProperties.js";

package/src/actions/primitives/semanticAction.js

@@ -57,7 +57,7 @@ function updateEntity(spec, parsed, value) {
         source.schema,
         value[0],
         undefined,
-        { sourceId: source.id, ownerId: parsed.id }
+        { sourceId: source.id, ownerId: parsed.id, sourceTransform: source.transform?.[0] }
       ));
     }
   }
@@ -72,6 +72,7 @@ function updateEntity(spec, parsed, value) {
     const schema = source?.schema !== undefined && current.transform?.length === 1
       ? deriveTransformSchema(source.schema, current.transform[0], value, {
           sourceId: source.id,
+          sourceTransform: source.transform?.[0],
           ownerId: parsed.id
         })
       : inferDatasetSchema(value);
@@ -225,6 +226,31 @@ export function withoutPreviewLayerEncodings(program, { id, channels }) {
   return program._clone({ semanticSpec });
 }
 
+// Composition materialization may retain this native two-scale guide meaning.
+// Use the existing semantic primitives on a private unit adapter; this does not
+// relax the public composition guard or accept arbitrary semantic paths.
+export function synchronizeFacetColorSizeMeaning(program, meaning) {
+  if (program.compositionSpec?.type !== "facet") {
+    throw new Error("Color-size parent meaning requires a facet composition.");
+  }
+  if (meaning !== undefined && (!isPlainObject(meaning) ||
+      Object.keys(meaning).some(key => !["colorScale", "sizeScale", "title"].includes(key)))) {
+    throw new Error("Color-size parent meaning requires its native scale bindings and title.");
+  }
+  let unit = new program.constructor({ semanticSpec: program.semanticSpec, graphicSpec: program.graphicSpec,
+    resolvedScales: program.resolvedScales, materializationConfigs: program.materializationConfigs,
+    context: program.context, trace: program.trace, actionStack: program.actionStack,
+    actionSequence: program._actionSequence });
+  if (unit.semanticSpec.guides.legend?.colorSize !== undefined) {
+    unit = unit.editSemantic({ property: "guide.legend.colorSize", remove: true });
+  }
+  if (meaning !== undefined) for (const [property, value] of Object.entries(meaning)) {
+    unit = unit.editSemantic({ property: `guide.legend.colorSize.${property}`, value });
+  }
+  return program._clone({ semanticSpec: unit.semanticSpec, context: unit.context,
+    trace: unit.trace, actionStack: unit.actionStack, actionSequence: unit._actionSequence });
+}
+
 export function createSemanticPrimitiveAction(validateSemanticValue, planNamedRemoval) {
   return closedAction(
     {

package/src/actions/primitives/semanticValidation/guide.js

@@ -1,3 +1,4 @@
+import {isSizeShapeChannels} from "../../../grammar/legendCombinations.js";
 import { normalizeLegendOrder } from "../../../grammar/categoryOrder.js";
 import { validateUserId } from "../../../core/identifiers.js";
 import { CATEGORICAL_LEGEND_CHANNELS } from "../../../core/vocabulary.js";
@@ -16,7 +17,7 @@ function validateLegend(property, value) {
     throw new Error(`Legend ${property} must not contain duplicates.`);
   }
   if (property === "channels") {
-    if (!value.every(channel => CATEGORICAL_LEGEND_CHANNELS.includes(channel))) {
+    if (!isSizeShapeChannels(value) && !value.every(channel => CATEGORICAL_LEGEND_CHANNELS.includes(channel))) {
       throw new Error("Legend channels support only color, strokeDash, and shape.");
     }
     return;
@@ -26,6 +27,11 @@ function validateLegend(property, value) {
 
 export function validateGuideSemanticValue(_program, parsed, value) {
   const property = parsed.path.at(-1);
+  if (parsed.id === "legend.colorSize") {
+    if(property === "title") validateNonEmptySemanticString(value,"Legend title");
+    else validateUserId(value,"Legend scale id");
+    return;
+  }
   if (parsed.id === "axis.parallel" && property === "titles") {
     validateParallelAxisTitles(value);
     return;
@@ -44,6 +50,10 @@ export function validateGuideSemanticValue(_program, parsed, value) {
       throw new TypeError("Parallel axis scales must contain at least two ids.");
     }
     value.forEach(id => validateUserId(id, "Parallel axis scale id"));
+  } else if (parsed.id.startsWith("axis.") && property === "channel") {
+    if (!["x", "y"].includes(value)) throw new Error("Named Cartesian axis channel requires x or y.");
+  } else if (parsed.id.startsWith("axis.") && property === "position") {
+    if (!["top", "bottom", "left", "right"].includes(value)) throw new Error("Named Cartesian axis position requires a physical side.");
   } else if (property === "title") {
     validateNonEmptySemanticString(value, "Axis title");
   } else {

package/src/actions/primitives/semanticValidation/layer.js

@@ -70,6 +70,10 @@ export function validateLayerSemanticValue(
       !["vertical", "horizontal"].includes(value))) {
     throw new Error("Bar orientation must be vertical or horizontal.");
   }
+  if (property === "mark.blend" &&
+      (findLayer(program, parsed.id)?.mark?.type !== "bar" || value !== "difference")) {
+    throw new Error("Bar blend must be difference; remove the optional intent for normal painting.");
+  }
   if (property === "derivedBindings.regression") {
     if (!value || typeof value !== "object" || Array.isArray(value) ||
         Object.keys(value).length !== 2 || value.mode !== "follow" ||

package/src/actions/regression/edit.js

@@ -19,6 +19,7 @@ import { findLayer } from "../../selectors/layers.js";
 import { removeOwnedMark } from "../marks/remove.js";
 import { removeOwnedColorLegends } from "../guides/legends/remove.js";
 import { requireRegressionField } from "./resolve.js";
+import { buildSourceRevisionPlan, applyRevisionPlan } from "../data/edit.js";
 
 const OPTIONS = Object.freeze([
   "target", "data", "x", "y", "groupBy", "method", "degree", "span", "robustIterations",
@@ -128,7 +129,7 @@ function resolveParameters(previous, args) {
         raw[key] = previous[key];
       }
     }
-  } else if (method !== "loess" && previous.method !== "loess" && args.interval !== false) {
+  } else if (!["loess", "exp"].includes(method) && !["loess", "exp"].includes(previous.method) && args.interval !== false) {
     for (const key of ["confidenceMethod", "level", "interval"]) {
       if (
         !Object.hasOwn(raw, key) &&
@@ -295,6 +296,11 @@ export const editRegression = /* @__PURE__ */ closedAction(
     const changesParameters = JSON.stringify(parameters) !==
       JSON.stringify(current.parameters);
     const changesStatistics = changesProvenance || changesParameters;
+    const hasStatistics = this.semanticSpec.datasets.some(dataset =>
+      dataset.source === current.dataId && dataset.transform?.[0]?.type === "regressionStatistics");
+    if (hasStatistics && parameters.method !== "linear") {
+      throw new Error("Remove dependent regression statistics before changing the linear fit method.");
+    }
     const bandPatch = Object.hasOwn(args, "band")
       ? validateBandPatch(args.band)
       : undefined;
@@ -302,14 +308,16 @@ export const editRegression = /* @__PURE__ */ closedAction(
       ? validateLinePatch(args.line)
       : undefined;
     if ((parameters.method === "loess" || parameters.interval === false) && bandPatch !== undefined && bandPatch !== false) {
-      throw new Error("LOESS regression does not support a band object.");
+      throw new Error(parameters.method === "loess"
+        ? "LOESS regression does not support a band object."
+        : "Regression interval false cannot include a band object.");
     }
 
     const hadBand = current.bandId !== undefined;
     const wantsBand = parameters.method !== "loess" && parameters.interval !== false &&
       (bandPatch === false
         ? false
-        : hadBand || bandPatch !== undefined || current.parameters.method === "loess");
+        : hadBand || bandPatch !== undefined || ["loess", "exp"].includes(current.parameters.method));
     const revision = changesStatistics
       ? planDerivedDataRevision(this, {
           owner: owner.id,
@@ -321,6 +329,8 @@ export const editRegression = /* @__PURE__ */ closedAction(
           ]
         })
       : undefined;
+    const statisticsRevision = changesStatistics && hasStatistics
+      ? buildSourceRevisionPlan(this, current.dataId, revision.id) : undefined;
 
     const applyEdit = program => {
       let dataId = current.dataId;
@@ -412,6 +422,8 @@ export const editRegression = /* @__PURE__ */ closedAction(
         }
       });
       if (changesStatistics) {
+        if (statisticsRevision !== undefined) next = applyRevisionPlan(next, undefined,
+          statisticsRevision, { retain: new Set([current.dataId]) });
         next = next.releaseDerivedData(revision.release);
       }
       const binding = findLayer(next, owner.id)?.derivedBindings?.regression;

package/src/actions/scales/channels.js

@@ -42,7 +42,7 @@ const DEFINITIONS = Object.freeze({
     channel: "color",
     options: Object.freeze([
       "type", "domain", "range", "emptyDomain", "clamp", "reverse", "palette",
-      "interpolate", "midpoint", "base", "constant", "unknown"
+      "interpolate", "whitePoint", "gamma", "midpoint", "base", "exponent", "constant", "unknown"
     ])
   }),
   editStrokeScale: Object.freeze({
@@ -50,7 +50,7 @@ const DEFINITIONS = Object.freeze({
     targetOnly: true,
     options: Object.freeze([
       "type", "domain", "range", "emptyDomain", "clamp", "reverse", "palette",
-      "interpolate", "midpoint", "base", "constant", "unknown"
+      "interpolate", "whitePoint", "gamma", "midpoint", "base", "exponent", "constant", "unknown"
     ])
   }),
   editSizeScale: Object.freeze({