ggaction 0.0.24 → 0.0.26

package/src/actions/guides/polar/axes/shared.js

@@ -20,11 +20,11 @@ export const TICK_EDIT_OPTIONS = Object.freeze([
 ]);
 export const LABEL_CREATE_OPTIONS = Object.freeze([
   "scale", "coordinate", "angle", "count", "values", "offset", "format",
-  "color", "fontSize", "fontFamily", "fontWeight"
+  "color", "fontSize", "fontFamily", "fontWeight", "align"
 ]);
 export const LABEL_EDIT_OPTIONS = Object.freeze([
   "count", "values", "offset", "format", "color", "fontSize",
-  "fontFamily", "fontWeight"
+  "fontFamily", "fontWeight", "align"
 ]);
 const THETA_LABEL_CREATE_OPTIONS = Object.freeze([
   ...LABEL_CREATE_OPTIONS,
@@ -44,10 +44,10 @@ export function labelEditOptions(kind) {
 }
 export const TITLE_CREATE_OPTIONS = Object.freeze([
   "scale", "coordinate", "angle", "text", "offset", "color", "fontSize",
-  "fontFamily", "fontWeight", "position"
+  "fontFamily", "fontWeight", "align", "position"
 ]);
 export const TITLE_EDIT_OPTIONS = Object.freeze([
-  "text", "offset", "color", "fontSize", "fontFamily", "fontWeight",
+  "text", "offset", "color", "fontSize", "fontFamily", "fontWeight", "align",
   "position"
 ]);
 

package/src/actions/guides/polar/axes/titles.js

@@ -1,6 +1,8 @@
 import { withGuideLayoutValidation } from "../../../../materialization/guides/layout.js";
 import { axisThemeTypography } from "../../../theme/state.js";
 import { action } from "../../../../core/action.js";
+import { resolveTextLines } from "../../../../core/textMetrics.js";
+import { materializeTextLines } from "../../../../materialization/textLines.js";
 import {
   validateNonEmptyString,
   validateNonNegativeFinite
@@ -33,7 +35,7 @@ import {
 
 function titleGeometry(program, kind, config, angle = resolveAngle(program, kind, {})) {
   const frame = resolvePolarFrameForProgram(program, config.coordinate);
-  return kind === "theta"
+  const geometry = kind === "theta"
     ? resolveThetaAxisTitle({ frame, offset: config.offset })
     : resolveRadialAxisTitle({
         frame,
@@ -41,6 +43,7 @@ function titleGeometry(program, kind, config, angle = resolveAngle(program, kind
         offset: config.offset,
         position: config.position
       });
+  return config.align === undefined ? geometry : { ...geometry, textAlign: config.align };
 }
 
 function validateTitleGeometry(program, kind, config, geometry, text) {
@@ -50,6 +53,7 @@ function validateTitleGeometry(program, kind, config, geometry, text) {
     items: [{
       ...geometry,
       text,
+      lines: titleLines(text, config, geometry),
       fontSize: config.fontSize,
       fontFamily: config.fontFamily,
       fontWeight: config.fontWeight
@@ -57,10 +61,17 @@ function validateTitleGeometry(program, kind, config, geometry, text) {
   }, program.materializationConfigs.textMetrics);
 }
 
+function titleLines(text, config, geometry) {
+  const lines = resolveTextLines(text, { fontSize: config.fontSize,
+    align: geometry.textAlign, baseline: geometry.textBaseline, blockAlign: "middle" });
+  return lines.length > 1 ? lines : undefined;
+}
+
 function resolveTitleConfig(program, kind, args, resources, previous) {
   const typography = axisThemeTypography(program.materializationConfigs.theme, "title");
   const config = {
     ...(previous ?? {}),
+    ...(Object.hasOwn(args, "align") ? { align: args.align } : {}),
     scale: resources.scale,
     coordinate: resources.coordinate,
     inferredText: previous?.inferredText ?? !Object.hasOwn(args, "text"),
@@ -136,7 +147,7 @@ function makeEditTitle(kind) {
     for (const [property, value] of Object.entries(properties)) {
       next = next.editGraphics({ target: names.title, property, value });
     }
-    return next;
+    return materializeTextLines(next, names.title, titleLines(text, config, geometry));
   }));
 }
 

package/src/actions/guides/polar/grids.js

@@ -1,3 +1,4 @@
+import { withGuideVisibilityPaint } from "../../../materialization/guides/visibility.js";
 import { editGraphicProperties } from "../../primitives/graphicProperties.js";
 import { action } from "../../../core/action.js";
 import {
@@ -25,7 +26,7 @@ const CREATE_OPTIONS = Object.freeze([
   "scale", "coordinate", "count", "values", "color", "lineWidth",
   "strokeDash"
 ]);
-const EDIT_OPTIONS = Object.freeze([
+const EDIT_OPTIONS = Object.freeze(["visible",
   "count", "values", "color", "lineWidth", "strokeDash"
 ]);
 
@@ -48,6 +49,7 @@ function validateStrokeDash(value) {
 }
 
 export function validatePolarGridOptions(args, operation, create) {
+  if (Object.hasOwn(args, "visible") && typeof args.visible !== "boolean") throw new TypeError("Grid visible must be a boolean.");
   validateOptionObject(
     args,
     create ? CREATE_OPTIONS : EDIT_OPTIONS,
@@ -86,6 +88,7 @@ function resolveConfig(program, kind, args, resources, previous) {
           : { mode: "count", count: previous.count, inferredValues: false };
   const config = {
     ...(previous ?? {}),
+    ...(Object.hasOwn(args, "visible") ? { visible: args.visible } : {}),
     kind,
     scale: resources.scale,
     coordinate: resources.coordinate,
@@ -156,7 +159,7 @@ function makeRematerialize(kind) {
   return action({
     op: operations.rematerialize,
     description: `Recompute concrete Polar ${kind} grid geometry.`
-  }, function (args = {}) {
+  }, withGuideVisibilityPaint(function (args = {}) {
     noOptions(args, operations.rematerialize);
     const config = this.guideConfigs.grid?.[kind];
     const semantic = this.semanticSpec.guides.grid?.[kind];
@@ -175,7 +178,7 @@ function makeRematerialize(kind) {
       refreshed,
       geometry
     );
-  });
+  }));
 }
 
 function makeCreate(kind) {

package/src/actions/guides/tickValues.js

@@ -41,7 +41,13 @@ export function inferHistogramBoundaries(program, channel, scaleId) {
     values.some((value, index) => value !== unique[index]))) {
     throw new Error(`Guide values cannot infer shared histogram bins for scale "${scaleId}".`);
   }
-  return unique;
+  const domain = program.resolvedScales[scaleId]?.domain;
+  // Retained histogram bins can extend beyond an auto domain after filtering.
+  // Inferred guides follow the displayed interval; user-specified tick values
+  // still use the normal strict validation path.
+  if (domain === undefined) return unique;
+  const minimum = Math.min(...domain), maximum = Math.max(...domain);
+  return unique.filter(value => value >= minimum && value <= maximum);
 }
 
 export function valuesFromTickConfig(program, config) {

package/src/actions/index.js

@@ -21,6 +21,7 @@ import { registerResourceActions } from "./resources/index.js";
 import { registerTextMetricActions } from "./textMetrics/index.js";
 import { registerCompositionActions } from "./composition/index.js";
 import { registerFacetActions } from "./facets/index.js";
+import { registerOverlayActions } from "./overlays/index.js";
 import { registerThemeActions } from "./theme/index.js";
 import {
   applyCompositionTheme,
@@ -38,6 +39,7 @@ export function registerActions(ProgramClass) {
   registerCanvasActions(ProgramClass);
   registerDataActions(ProgramClass);
   registerMarkActions(ProgramClass);
+  registerOverlayActions(ProgramClass);
   registerScaleActions(ProgramClass);
   registerEncodingActions(ProgramClass);
   registerBasicCoordinateActions(ProgramClass);

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

@@ -194,6 +194,7 @@ const rematerializeAreaMark = /* @__PURE__ */ action(
     }
     const colorEncoding = layer.encoding?.color;
     const strokeEncoding = layer.encoding?.stroke;
+    const opacityEncoding = layer.encoding?.opacity;
     let resolved = args.scales === false
       ? this
       : this
@@ -205,8 +206,11 @@ const rematerializeAreaMark = /* @__PURE__ */ action(
     if (args.scales !== false && strokeEncoding?.scale !== undefined) {
       resolved = resolved.rematerializeScale({ id: strokeEncoding.scale });
     }
+    if (args.scales !== false && opacityEncoding?.scale !== undefined) {
+      resolved = resolved.rematerializeScale({ id: opacityEncoding.scale });
+    }
     const config = validateAreaPaintConfig(this.markConfigs[id]);
-    const { paths, fills, strokes } = resolveAreaMaterialization({
+    const { paths, fills, strokes, opacities } = resolveAreaMaterialization({
       rows: dataset.values,
       layer,
       densityTransform,
@@ -227,7 +231,7 @@ const rematerializeAreaMark = /* @__PURE__ */ action(
       length: paths.length,
       commands: paths,
       fill: fills,
-      opacity: config.opacity,
+      opacity: opacities ?? config.opacity ?? 0.2,
       ...(hasOutline ? {
         stroke: strokes ?? (config.strokeFromFill === true ? fills : config.stroke),
         strokeWidth: config.strokeWidth ?? (strokes === undefined ? undefined : 1)
@@ -273,6 +277,9 @@ const editAreaMark = /* @__PURE__ */ action(
         "editAreaMark stroke conflicts with a field encoding; use encodeStroke with value to replace it."
       );
     }
+    if (Object.hasOwn(args, "opacity") && layer.encoding?.opacity !== undefined) {
+      throw new Error("editAreaMark opacity conflicts with a field encoding; use encodeOpacity with value to replace it.");
+    }
     if (args.stroke === false && Object.hasOwn(args, "strokeWidth")) {
       throw new Error("editAreaMark cannot set strokeWidth while removing stroke.");
     }

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

@@ -1 +1 @@
-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};
+import{deriveCenteredAreaSeries as E,deriveAreaSeries as w,deriveDensityAreaSeries as z,layoutDensityAreaSeries as q}from"../../../grammar/areaSeries.js";import{mapContinuousScaleValues as s,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 C}from"../../../grammar/pathCommands.js";import{buildCategoricalDensityPaths as B}from"../../../grammar/categoricalDensity.js";import{derivePathSeriesFieldValues as k}from"../../../grammar/pathSeries.js";function F({derived:p,densityTransform:o,categoricalDensity:m,xScale:c,yScale:u,densityScale:x,layout:v,curve:r}){return m?B(p,{categoryScale:o.placement.channel==="x"?c:u,valueScale:o.placement.channel==="x"?u:c,curve:r}):p.series.map(t=>{if(o===void 0&&p.orientation==="horizontal"){const e=(["point","band"].includes(u.type)?D:s)(t.values.map(n=>n.y),u),a=s(t.values.map(n=>n.x),c),d=s(t.values.map(n=>n.x2),c);return A(e.map((n,l)=>({x:a[l],y:n})),e.map((n,l)=>({x:d[l],y:n})),r,{independentAxis:"y"})}if(o!==void 0&&p.mode==="x-density"){const e=(["point","band"].includes(u.type)?D:s)(t.values.map(n=>n.y),u),a=s(t.values.map(n=>n.x),c),d=s([0],x)[0];return r==="linear"?C([{x:d,y:e[0]},...e.map((n,l)=>({x:a[l],y:n})),{x:d,y:e.at(-1)}],{close:!0}):A(e.map(n=>({x:d,y:n})),e.map((n,l)=>({x:a[l],y:n})),r,{independentAxis:"y"})}const i=(["point","band"].includes(c.type)?D:s)(t.values.map(e=>e.x),c),h=o===void 0?p.mode==="y-center"?t.values.map(e=>e.lower):t.values.map(e=>e.y):p.mode==="y-density"?t.values.map(e=>e.lower):t.values.map(e=>e.y),g=s(h,u),f=o===void 0?p.mode==="y-center"?t.values.map(e=>e.upper):t.values.map(e=>e.y2):t.values.map(e=>e.upper),y=s(f,u);if(o!==void 0&&v==="overlay"){const e=s([0],u)[0];return r==="linear"?C([{x:i[0],y:e},...i.map((a,d)=>({x:a,y:y[d]})),{x:i.at(-1),y:e}],{close:!0}):A(i.map(a=>({x:a,y:e})),i.map((a,d)=>({x:a,y:y[d]})),r)}return A(i.map((e,a)=>({x:e,y:g[a]})),i.map((e,a)=>({x:e,y:y[a]})),r)})}function I({rows:p,layer:o,densityTransform:m,resolvedScales:c,config:u}){const x=c[o.encoding.x.scale],v=c[o.encoding.y.scale],r=m===void 0&&o.encoding?.y?.stack==="center",t=m===void 0?r?E(p,o,{xDomain:x.domain}):w(p,o,{xDomain:x.domain,yDomain:v.domain}):z(p,o,m),i=o.encoding?.color,h=o.layout?.mode??i?.layout??"overlay",g=m?.placement?.type==="category",f=m===void 0||g?t:q(t,h),y=m===void 0||g?void 0:f.mode==="y-density"?v:x;if(y!==void 0&&(y.domain[0]>0||y.domain[1]<0))throw new Error(`Density area mark "${o.id}" requires a scale domain containing zero.`);const e=F({derived:f,densityTransform:m,categoricalDensity:g,xScale:x,yScale:v,densityScale:y,layout:h,curve:u.curve??"linear"}),a=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)?f.series.map(V=>V.key[i.field]):k(p,f.series,i.field,"color",i),c[i.scale],"color"),d=o.encoding?.stroke,n=d?.scale===void 0?void 0:b(k(p,f.series,d.field,"stroke",d),c[d.scale],"stroke"),l=o.encoding?.opacity,P=l?.scale===void 0?void 0:b(k(p,f.series,l.field,"opacity",l),c[l.scale],"opacity");return{paths:e,fills:a,strokes:n,opacities:P}}export{I as resolveAreaMaterialization};

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

@@ -12,7 +12,7 @@ import {
   BAR_GRAINS,
   resolveBarOffsetChannel
 } from "../../../grammar/bars/policy.js";
-import { rematerializeHighlightBaseline } from "../lifecycle.js";
+import { rematerializeHighlightBaseline, materializeFollowingOverlays } from "../lifecycle.js";
 import { offsetCategoryRectangles } from
   "../../../materialization/categorySlotOffset.js";
 import { materializeRectItem, RECT_STYLE_PROPERTIES } from "../../../grammar/roundedRect.js";
@@ -30,12 +30,12 @@ function editRectangles(program, id, rectangles) {
     item.properties?.blend !== undefined);
   if (hasShapeStyle || blend !== undefined || previousBlend) {
     const radius = appearance;
-    return materializeMarkClip(replaceGraphicItems(
+    return materializeFollowingOverlays(materializeMarkClip(replaceGraphicItems(
       program,
       id,
       "rect",
       rectangles.map(rectangle => materializeRectItem(rectangle, radius))
-    ), id);
+    ), id), id);
   }
   let next = editGraphicProperties(program, id, {
     length: rectangles.length,
@@ -54,7 +54,7 @@ function editRectangles(program, id, rectangles) {
       value: rectangles.map(rect => rect.opacity ?? 1)
     });
   }
-  return materializeMarkClip(next, id);
+  return materializeFollowingOverlays(materializeMarkClip(next, id), id);
 }
 
 export const rematerializeBarMark = /* @__PURE__ */ action(

package/src/actions/marks/lifecycle.js

@@ -1,3 +1,17 @@
+// Called explicitly by source mark materializers after their concrete geometry is complete.
+// A surrounding plan owns any overlay rebuild that it has already scheduled.
+export function materializeFollowingOverlays(program, source) {
+  const pending = program.context?.pendingMaterializationPlan;
+  const scheduled = new Set((pending?.steps.slice(pending.next) ?? [])
+    .filter(step => step.op === "rematerializeOverlay").map(step => step.args.id));
+  for (const layer of program.semanticSpec.layers) {
+    if (layer.derivedBindings?.overlay?.source === source && !scheduled.has(layer.id)) {
+      program = program.rematerializeOverlay({ id: layer.id });
+    }
+  }
+  return program;
+}
+
 export function rematerializeHighlightBaseline(program, {
   target,
   operation,

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

@@ -1,3 +1,4 @@
+import { assertIndependentOverlayGeometry } from "../../../grammar/overlay.js";
 import { requestedMarkClip, validateMarkClipCoordinate } from "../../../selectors/markClip.js";
 import { action } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
@@ -209,6 +210,7 @@ const rematerializeLineMark = /* @__PURE__ */ action(
       "rematerializeLineMark"
     );
     const id = validateUserId(args.id, "Line mark id");
+    if (findLayer(this, id)?.derivedBindings?.overlay) return this.rematerializeOverlay({ id });
     const highlighted = rematerializeHighlightBaseline(this, {
       target: id,
       operation: "rematerializeLineMark",
@@ -301,6 +303,7 @@ const editLineMark = /* @__PURE__ */ action(
       predicate: candidate => candidate.mark?.type === "line",
       label: "line mark"
     });
+    if (Object.hasOwn(args, "missing")) assertIndependentOverlayGeometry(layer, "editLineMark missing");
     if (Object.hasOwn(args, "stroke") && (
       layer.encoding?.color !== undefined ||
       layer.encoding?.stroke !== undefined

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

@@ -101,7 +101,7 @@ export function resolvePositionedLineMaterialization({
   const radiusScaleId = layer.encoding?.radius?.scale;
   const lineOptions = polar
     ? { thetaDomain: resolvedScales[thetaScaleId].domain }
-    : { xBinBoundaries, xDomain: resolvedScales[xScaleId].domain };
+    : { xBinBoundaries, xDomain: resolvedScales[xScaleId].domain, yDomain: resolvedScales[yScaleId].domain };
   const derived = deriveLineSeries(rows, layer, { ...lineOptions, scales: resolvedScales });
   const commands = polar
     ? derived.series.map(series => buildPolarLinePathCommands({
@@ -119,7 +119,9 @@ export function resolvePositionedLineMaterialization({
           series.values.map(value => value.x),
           resolvedScales[xScaleId]
         );
-        const y = mapContinuousScaleValues(
+        const mapY = ["nominal", "ordinal"].includes(layer.encoding.y.fieldType)
+          ? mapOrdinalPositionValues : mapContinuousScaleValues;
+        const y = mapY(
           series.values.map(value => value.y),
           resolvedScales[yScaleId]
         );

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

@@ -1,3 +1,4 @@
+import { assertIndependentOverlayGeometry } from "../../../grammar/overlay.js";
 import { requestedMarkClip, validateMarkClipCoordinate } from "../../../selectors/markClip.js";
 import { action } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
@@ -45,6 +46,7 @@ export const editPointMark = /* @__PURE__ */ action(
       predicate: candidate => candidate.mark?.type === "point",
       label: "point mark"
     });
+    if (Object.hasOwn(args, "missing")) assertIndependentOverlayGeometry(layer, "editPointMark missing");
     const id = layer.id;
     if (Object.hasOwn(args, "shape") && layer.encoding?.shape !== undefined) {
       throw new Error(

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

@@ -1,3 +1,4 @@
+import { assertIndependentOverlayGeometry } from "../../../grammar/overlay.js";
 import { closedAction } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
 
@@ -36,6 +37,7 @@ export const jitterPoints = /* @__PURE__ */ closedAction(
   function (args = {}) {
     const policy = normalizePointJitterPolicy(args);
     const layer = resolveJitterTarget(this, args.target);
+    assertIndependentOverlayGeometry(layer, "jitterPoints");
     if (this.materializationConfigs.pointPacking?.[layer.id] !== undefined) {
       throw new Error(`Point jitter on "${layer.id}" conflicts with point packing.`);
     }

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

@@ -34,7 +34,7 @@ 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 { rematerializeHighlightBaseline, materializeFollowingOverlays } from "../lifecycle.js";
 import {
   resolveRowEncodingValues,
   resolveRowPositionValues
@@ -307,6 +307,7 @@ export const rematerializePointMark = /* @__PURE__ */ action(
   function (args = {}) {
     validateMarkOptions(args, REMATERIALIZE_OPTIONS, "rematerializePointMark");
     const id = validateUserId(args.id, "Point mark id");
+    if (findLayer(this, id)?.derivedBindings?.overlay) return this.rematerializeOverlay({ id });
     const highlighted = rematerializeHighlightBaseline(this, {
       target: id,
       operation: "rematerializePointMark",
@@ -453,11 +454,11 @@ export const rematerializePointMark = /* @__PURE__ */ action(
           ...strokeDetails
         });
       });
-      return materializeMarkClip(jittered.program.editGraphics({
+      return materializeFollowingOverlays(materializeMarkClip(jittered.program.editGraphics({
         target: id,
         property: "items",
         value: items
-      }), id);
+      }), id), id);
     }
 
     let next = graphic.items.length === dataset.values.length
@@ -552,6 +553,6 @@ export const rematerializePointMark = /* @__PURE__ */ action(
     for (const [property, value] of Object.entries(strokeDetails)) {
       next = next.editGraphics({ target: id, property, value });
     }
-    return materializeMarkClip(next, id);
+    return materializeFollowingOverlays(materializeMarkClip(next, id), id);
   }
 );

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

@@ -1,3 +1,4 @@
+import { assertIndependentOverlayGeometry } from "../../../grammar/overlay.js";
 import { closedAction } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
 
@@ -33,6 +34,7 @@ export const packPoints = /* @__PURE__ */ closedAction(
   function (args = {}) {
     const policy = normalizePointPackingPolicy(args);
     const layer = target(this, args.target, policy.channel);
+    assertIndependentOverlayGeometry(layer, "packPoints");
     if (this.materializationConfigs.jitters?.[layer.id] !== undefined) {
       throw new Error(`Point packing on "${layer.id}" conflicts with point jitter.`);
     }

package/src/actions/marks/references.js

@@ -410,14 +410,16 @@ function resolvePopulationValues(
     const { field } = resolveBoundPopulation(program, source, config, referenceId);
     if (field !== undefined) return strictFieldValues(dataset.values, field,
       `Statistical reference "${referenceId}" boundData`);
-    if (source.mark.type === "line" && isAggregate(source.encoding?.y?.aggregate)) {
+    if (source.mark.type === "line" && (isAggregate(source.encoding?.y?.aggregate) || isAggregate(source.encoding?.x?.aggregate))) {
       const x = source.encoding.x;
       const bins = x.bin === undefined ? undefined : resolveLineBins(
         dataset.values, source, findSemanticScale(program, x.scale)
       );
       const derived = deriveLineSeries(dataset.values, source, {
         ...(bins === undefined ? {} : { xBinBoundaries: bins.boundaries }),
-        allowSingleton: true
+        allowSingleton: true,
+        xDomain: program.resolvedScales[source.encoding.x.scale]?.domain,
+        yDomain: program.resolvedScales[source.encoding.y.scale]?.domain
       });
       return config.axis === "x" ? derived.xValues : derived.yValues;
     }
@@ -458,7 +460,7 @@ function statisticalRows(program, referenceId) {
   );
   const { dataset } = resolveBoundPopulation(program, source, { ...config, population }, referenceId);
   const groupBy = normalizeReferenceGroupBy(config.groupBy);
-  if (population === "visibleItems" && findSelectionPolicy(source.mark?.type) === undefined) {
+  if (population === "visibleItems" && (source.mark?.type === "text" || findSelectionPolicy(source.mark?.type) === undefined)) {
     throw new Error(
       `Statistical reference "${referenceId}" visibleItems population is unavailable for ${source.mark?.type} marks. Use boundData.`
     );

package/src/actions/marks/remove.js

@@ -4,6 +4,7 @@ import { isSourceOwnedText } from "../../grammar/text.js";
 import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 
+import { findSemanticScale } from "../../selectors/scales.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { findLayer } from "../../selectors/layers.js";
 import { applyDetachedScaleRematerialization } from "../../materialization/dependencies.js";
@@ -113,6 +114,13 @@ function ownedDerivedData(program, ids) {
       candidates.add(dataset.id);
     }
   }
+  // Release leaf transforms before their complete-case input chain.
+  for (const id of ids) {
+    const config = program.markConfigs[id] ?? {};
+    for (const data of config.alignedPositionData ?? []) candidates.add(data);
+    for (const data of config.raincloudPlot?.ownedData ?? config.endpointPlot?.ownedData ?? []) candidates.add(data);
+    for (const data of [...(config.radarPlot?.ownedData ?? [])].reverse()) candidates.add(data);
+  }
   return candidates;
 }
 
@@ -165,6 +173,7 @@ export function removeOwnedMark(program, id, partial = false) {
   }
   return next
     ._withoutMaterializationConfig(["guides", "legendGroups", id])
+    ._withoutMaterializationConfig(["guides", "suppressedLegends", id])
     ._withoutMaterializationConfig(["marks", id])
     ._withContext({
       ...(program.context.currentMark === id ? { currentMark: undefined } : {}),
@@ -222,6 +231,7 @@ export const removeMark = /* @__PURE__ */ closedAction(
     }
     const previousLayers = ids.map(id => findLayer(this, id));
     const derived = ownedDerivedData(this, ids);
+    const ownedScales = new Set(ids.map(id => this.markConfigs[id]?.seriesOffsetScale).filter(Boolean));
     const positionScales = usedPositionScales(this, ids);
     let next = this;
 
@@ -264,6 +274,7 @@ export const removeMark = /* @__PURE__ */ closedAction(
         next = next.editGraphics({ target: id, remove: true });
       }
       next = next._withoutMaterializationConfig(["guides", "legendGroups", id]);
+      next = next._withoutMaterializationConfig(["guides", "suppressedLegends", id]);
       next = next._withoutMaterializationConfig(["marks", id]);
       next = next._withoutMaterializationConfig(["jitters", id]);
       next = next._withoutMaterializationConfig(["pointPacking", id]);
@@ -277,6 +288,11 @@ export const removeMark = /* @__PURE__ */ closedAction(
       }
     }
     next = applyDetachedScaleRematerialization(next, previousLayers);
+    for (const id of ownedScales) {
+      const references = collectResourceReferences(next, { kind: "scale", id })
+        .filter(reference => reference.strength !== "context");
+      if (references.length === 0 && findSemanticScale(next, id) !== undefined) next = next.removeScale({ id });
+    }
     return next._withContext({
       ...(ids.includes(this.context.currentMark) ? { currentMark: undefined } : {}),
       ...(selectionCleanup.selectionIds.includes(this.context.currentSelection)

package/src/actions/marks/shared.js

@@ -1,4 +1,5 @@
 import { materializeMarkClip } from "../../materialization/markClip.js";
+import { materializeFollowingOverlays } from "./lifecycle.js";
 import { isSourceOwnedText } from "../../grammar/text.js";
 import {
   resolveOptionalUserId,
@@ -244,5 +245,5 @@ export function editMarkGraphic(program, target, properties) {
   for (const [property, value] of Object.entries(properties)) {
     program = program.editGraphics({ target, property, value });
   }
-  return materializeMarkClip(program, target);
+  return materializeFollowingOverlays(materializeMarkClip(program, target), target);
 }

package/src/actions/marks/text/actions.js

@@ -1,3 +1,4 @@
+import { rematerializeHighlightBaseline } from "../lifecycle.js";
 import { materializeMarkClip } from "../../../materialization/markClip.js";
 import { requestedMarkClip, validateMarkClipCoordinate } from "../../../selectors/markClip.js";
 import { TEXT_LABEL_LAYOUT_OPTIONS } from "./layout.js";
@@ -46,7 +47,7 @@ import { validateItemMissing } from "../../../grammar/itemMissing.js";
 
 const STYLE_OPTIONS = Object.freeze(["clip", ...TEXT_MARK_STYLE_OPTIONS]);
 const CREATE_OPTIONS = Object.freeze(["id", "data", "source", "text", "missing", ...STYLE_OPTIONS]);
-const EDIT_OPTIONS = Object.freeze(["target", "missing", ...STYLE_OPTIONS]);
+const EDIT_OPTIONS = Object.freeze(["target", "missing", "textOverrides", ...STYLE_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id", "replayLayout"]);
 
 function sourceMatchesData(program, layer, requestedData) {
@@ -460,6 +461,8 @@ const rematerializeTextMark = /* @__PURE__ */ action(
           ? next
           : next.materializeMarkLabelPlacement({ id });
     }
+    const highlighted = rematerializeHighlightBaseline(this, { target: id, operation: 'rematerializeTextMark', resetProperty: 'items', resetValue: [] });
+    if (highlighted) return highlighted;
     let next = materializeMarkClip(this.editGraphics({
       target: id,
       property: "items",
@@ -486,7 +489,7 @@ const editTextMark = /* @__PURE__ */ action(
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editTextMark");
     requestedMarkClip(args);
-    if (!["missing", ...STYLE_OPTIONS].some(option => Object.hasOwn(args, option))) {
+    if (!["missing", "textOverrides", ...STYLE_OPTIONS].some(option => Object.hasOwn(args, option))) {
       throw new Error("editTextMark requires at least one editable property.");
     }
     const layer = requireTextLayer(this, args.target, "editTextMark");