ggaction 0.0.13 → 0.0.16

package/src/actions/charts/horizon.js

@@ -1,4 +1,5 @@
 import { action } from "../../core/action.js";
+import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import { validateNonEmptyString, validateOptionObject, validateUnitInterval } from "../../core/validation.js";
 import {
   applyFacadeGuides, normalizeAppearance, normalizeFieldEncoding, normalizeGuides,
@@ -40,7 +41,7 @@ function guideOptions(value) {
   return guides;
 }
 
-export const createHorizonPlot = action({
+export const createHorizonPlot = /* @__PURE__ */ action({
   op: OPERATION, description: "Create a signed, folded horizon area with original-x guides."
 }, function (args = {}) {
   validateFacadeOptions(args, OPTIONS, OPERATION);
@@ -51,7 +52,8 @@ export const createHorizonPlot = action({
   const { id: requestedId, data: requestedData, coordinate, x: requestedX, y: requestedY,
     area: requestedArea, guides: requestedGuides, ...horizon } = omitUndefinedOptions(args);
   const { opacity, ...area } = omitUndefinedOptions(normalizeAppearance(requestedArea,
-    ["opacity", "stroke", "strokeWidth", "curve"], `${OPERATION} area`));
+    ["opacity", "stroke", "strokeWidth", "curve", ...STROKE_STYLE_PROPERTIES],
+    `${OPERATION} area`));
   for (const [key, value] of Object.entries({ ...horizon, ...area })) {
     if (value === null) throw new TypeError(`${OPERATION} ${key} cannot be null.`);
   }

package/src/actions/charts/interval-regression.js

@@ -1,6 +1,7 @@
 import { action } from "../../core/action.js";
 import { validateNonNegativeFinite } from "../../core/validation.js";
 import { findDataset } from "../../selectors/datasets.js";
+import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
   applyFacadeGuides,
   normalizeAppearance,
@@ -18,10 +19,12 @@ const INTERVAL_OPTIONS = Object.freeze([
   "color", "point", "errorBar", "guides"
 ]);
 const POINT_OPTIONS = Object.freeze([
-  "shape", "fill", "opacity", "stroke", "strokeWidth", "radius"
+  "shape", "fill", "opacity", "stroke", "strokeWidth", "radius",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 const ERROR_BAR_OPTIONS = Object.freeze([
-  "caps", "capSize", "stroke", "strokeWidth", "strokeDash", "opacity"
+  "caps", "capSize", "stroke", "strokeWidth", "strokeDash", "opacity",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 
 function intervalChannel(value, operation, channel, id) {
@@ -79,7 +82,7 @@ function applyIntervalPointPositions(program, id, config) {
   return next;
 }
 
-export const createIntervalPlot = action(
+export const createIntervalPlot = /* @__PURE__ */ action(
   {
     op: "createIntervalPlot",
     description: "Create a center point and matching statistical or explicit interval."
@@ -136,7 +139,7 @@ const REGRESSION_OPTIONS = Object.freeze([
   "interval", "band", "line", "guides"
 ]);
 
-export const createRegressionPlot = action(
+export const createRegressionPlot = /* @__PURE__ */ action(
   {
     op: "createRegressionPlot",
     description: "Create a scatter plot with a fitted regression line and optional interval band."

package/src/actions/charts/line.js

@@ -1,5 +1,6 @@
 import { action } from "../../core/action.js";
 import { normalizeGroupFields } from "../../grammar/pathSeries.js";
+import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
   applyFacadeGuides,
   normalizeAppearance,
@@ -19,10 +20,11 @@ const OPTIONS = Object.freeze([
   "strokeDash", "line", "guides"
 ]);
 const LINE_OPTIONS = Object.freeze([
-  "strokeWidth", "curve", "stroke", "opacity", "closed"
+  "strokeWidth", "curve", "stroke", "opacity", "closed",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 
-export const createLinePlot = action(
+export const createLinePlot = /* @__PURE__ */ action(
   {
     op: "createLinePlot",
     description: "Create a Cartesian line plot from existing chart data."

package/src/actions/charts/parallel.js

@@ -1,5 +1,6 @@
 import { action } from "../../core/action.js";
 import { resolveParallelCoordinate } from "../coordinates/parallel.js";
+import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
   applyFacadeGuides,
   normalizeAppearance,
@@ -17,7 +18,8 @@ const OPTIONS = Object.freeze([
   "color", "strokeDash", "line", "guides"
 ]);
 const LINE_OPTIONS = Object.freeze([
-  "strokeWidth", "stroke", "opacity", "curve", "closed"
+  "strokeWidth", "stroke", "opacity", "curve", "closed",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 
 function scopeParallelGuides(guides, coordinate) {
@@ -51,7 +53,7 @@ function scopeParallelGuides(guides, coordinate) {
   };
 }
 
-export const createParallelCoordinates = action(
+export const createParallelCoordinates = /* @__PURE__ */ action(
   {
     op: "createParallelCoordinates",
     description: "Create a complete Parallel-coordinates chart."
@@ -105,6 +107,10 @@ export const createParallelCoordinates = action(
     if (strokeDash !== undefined) {
       next = next.encodeStrokeDash(targetArgs(strokeDash, id));
     }
-    return applyFacadeGuides(next, guides, id);
+    next = applyFacadeGuides(next, guides, id);
+    return next._withMarkConfig(id, {
+      ...next.markConfigs[id],
+      compositionRole: "parallel"
+    });
   }
 );

package/src/actions/charts/pie.js

@@ -1,4 +1,5 @@
 import { action } from "../../core/action.js";
+import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
   applyFacadeGuides, normalizeAppearance, normalizeCategoricalColor, normalizeCategoricalGuides,
   normalizeArcCategory, normalizeCategoryAggregate, omitUndefinedOptions,
@@ -7,7 +8,10 @@ import {
 
 const OPERATION = "createPiePlot";
 const OPTIONS = ["id", "data", "coordinate", "category", "value", "aggregate", "color", "arc", "guides"];
-const ARC_OPTIONS = ["innerRadius", "padAngle", "fill", "opacity", "stroke", "strokeWidth"];
+const ARC_OPTIONS = [
+  "innerRadius", "padAngle", "fill", "opacity", "stroke", "strokeWidth",
+  ...STROKE_STYLE_PROPERTIES
+];
 function guideOptions(value, color) {
   const guides = normalizeCategoricalGuides(value, OPERATION, color);
   if (guides === false) return false;
@@ -19,7 +23,7 @@ function guideOptions(value, color) {
   return { ...guides, axes: false, grid: false };
 }
 
-export const createPiePlot = action({
+export const createPiePlot = /* @__PURE__ */ action({
   op: OPERATION, description: "Create a categorical count or weighted-sum pie or donut plot."
 }, function (args = {}) {
   validateFacadeOptions(args, OPTIONS, OPERATION);
@@ -40,5 +44,9 @@ export const createPiePlot = action({
     ...(aggregate === "sum" ? { weight: args.value } : {})
   });
   if (color !== undefined) next = next.encodeColor({ ...color, target: id });
-  return applyFacadeGuides(next, guides, id, args.guides ?? {});
+  next = applyFacadeGuides(next, guides, id, args.guides ?? {});
+  return next._withMarkConfig(id, {
+    ...next.markConfigs[id],
+    compositionRole: "pie"
+  });
 });

package/src/actions/charts/polar.js

@@ -2,6 +2,7 @@ import { action } from "../../core/action.js";
 import { validateNonNegativeFinite, validateOptionObject } from
   "../../core/validation.js";
 import { normalizeGroupFields } from "../../grammar/pathSeries.js";
+import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
   applyFacadeGuides,
   normalizeAppearance,
@@ -20,10 +21,12 @@ const POSITION_OPTIONS = Object.freeze([
   "field", "fieldType", "temporalUnit", "scale"
 ]);
 const POINT_OPTIONS = Object.freeze([
-  "shape", "fill", "opacity", "stroke", "strokeWidth", "radius"
+  "shape", "fill", "opacity", "stroke", "strokeWidth", "radius",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 const LINE_OPTIONS = Object.freeze([
-  "strokeWidth", "curve", "stroke", "opacity", "closed"
+  "strokeWidth", "curve", "stroke", "opacity", "closed",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 
 function position(value, operation, channel) {
@@ -36,7 +39,7 @@ function position(value, operation, channel) {
   return resolved;
 }
 
-export const createPolarScatterPlot = action(
+export const createPolarScatterPlot = /* @__PURE__ */ action(
   {
     op: "createPolarScatterPlot",
     description: "Create a Polar scatter plot with distinct radial position and glyph size."
@@ -78,11 +81,15 @@ export const createPolarScatterPlot = action(
     if (color !== undefined) next = next.encodeColor(targetArgs(color, id));
     if (size !== undefined) next = next.encodeSize(targetArgs(size, id));
     if (shape !== undefined) next = next.encodeShape(targetArgs(shape, id));
-    return applyFacadeGuides(next, guides, id);
+    next = applyFacadeGuides(next, guides, id);
+    return next._withMarkConfig(id, {
+      ...next.markConfigs[id],
+      compositionRole: "polar-point"
+    });
   }
 );
 
-export const createPolarLinePlot = action(
+export const createPolarLinePlot = /* @__PURE__ */ action(
   {
     op: "createPolarLinePlot",
     description: "Create an open or explicitly closed Polar line plot."
@@ -118,6 +125,10 @@ export const createPolarLinePlot = action(
     if (groupBy !== undefined) next = next.encodeGroup({ target: id, fields: groupBy });
     if (color !== undefined) next = next.encodeColor(targetArgs(color, id));
     if (strokeDash !== undefined) next = next.encodeStrokeDash(targetArgs(strokeDash, id));
-    return applyFacadeGuides(next, guides, id);
+    next = applyFacadeGuides(next, guides, id);
+    return next._withMarkConfig(id, {
+      ...next.markConfigs[id],
+      compositionRole: "polar-line"
+    });
   }
 );

package/src/actions/charts/radar.js

@@ -1,4 +1,5 @@
 import { action } from "../../core/action.js";
+import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validateNonEmptyString, validateOptionObject } from
   "../../core/validation.js";
@@ -31,7 +32,8 @@ const CATEGORY_SCALE_OPTIONS = Object.freeze([
 const WIDE_OPTIONS = Object.freeze(["fields", "as"]);
 const WIDE_AS_OPTIONS = Object.freeze(["key", "value"]);
 const LINE_OPTIONS = Object.freeze([
-  "strokeWidth", "curve", "stroke", "opacity", "closed"
+  "strokeWidth", "curve", "stroke", "opacity", "closed",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 
 function normalizeCategory(value, operation) {
@@ -183,7 +185,7 @@ function scaleWithOrder(category, order, operation) {
   return { ...category, scale: { ...scale, domain: order } };
 }
 
-export const createRadarPlot = action(
+export const createRadarPlot = /* @__PURE__ */ action(
   {
     op: "createRadarPlot",
     description: "Create a closed Radar plot from long rows or an explicit wide fold."
@@ -283,7 +285,7 @@ export const createRadarPlot = action(
     }
 
     category = scaleWithOrder(category, order, operation);
-    return next.createPolarLinePlot({
+    next = next.createPolarLinePlot({
       id,
       data,
       ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate }),
@@ -295,5 +297,9 @@ export const createRadarPlot = action(
       line: { ...line, closed: true },
       guides
     });
+    return next._withMarkConfig(id, {
+      ...next.markConfigs[id],
+      compositionRole: "radar"
+    });
   }
 );

package/src/actions/charts/radial.js

@@ -1,4 +1,5 @@
 import { action } from "../../core/action.js";
+import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
   applyFacadeGuides, normalizeAppearance, normalizeArcCategory, normalizeCategoryAggregate,
   normalizeCategoricalColor, normalizeCategoricalGuides, omitUndefinedOptions,
@@ -6,7 +7,10 @@ import {
 } from "./shared.js";
 
 const OPTIONS = ["id", "data", "coordinate", "category", "value", "aggregate", "radiusScale", "color", "arc", "guides"];
-const ARC_OPTIONS = ["innerRadius", "padAngle", "fill", "opacity", "stroke", "strokeWidth"];
+const ARC_OPTIONS = [
+  "innerRadius", "padAngle", "fill", "opacity", "stroke", "strokeWidth",
+  ...STROKE_STYLE_PROPERTIES
+];
 const RADIUS_OPTIONS = ["id", "type", "domain", "range", "zero", "nice", "reverse", "clamp"];
 
 function createMeasuredPlot(program, args, { operation, defaultId, mapping }) {
@@ -31,12 +35,16 @@ function createMeasuredPlot(program, args, { operation, defaultId, mapping }) {
     ...(aggregate === "sum" ? { field: args.value } : {}),
     ...(radiusScale === undefined ? {} : { scale: radiusScale }) });
   if (color !== undefined) next = next.encodeColor({ ...color, target: id });
-  return applyFacadeGuides(next, guides, id, args.guides ?? {});
+  next = applyFacadeGuides(next, guides, id, args.guides ?? {});
+  return next._withMarkConfig(id, {
+    ...next.markConfigs[id],
+    compositionRole: "rose"
+  });
 }
 
-export const createRosePlot = action({ op: "createRosePlot", description: "Create equal-angle sectors with area proportional to category count or sum." }, function (args = {}) {
+export const createRosePlot = /* @__PURE__ */ action({ op: "createRosePlot", description: "Create equal-angle sectors with area proportional to category count or sum." }, function (args = {}) {
   return createMeasuredPlot(this, args, { operation: "createRosePlot", defaultId: "rosePlot", mapping: "area" });
 });
-export const createRadialBarPlot = action({ op: "createRadialBarPlot", description: "Create equal-angle sectors with radial length proportional to category count or sum." }, function (args = {}) {
+export const createRadialBarPlot = /* @__PURE__ */ action({ op: "createRadialBarPlot", description: "Create equal-angle sectors with radial length proportional to category count or sum." }, function (args = {}) {
   return createMeasuredPlot(this, args, { operation: "createRadialBarPlot", defaultId: "radialBarPlot", mapping: "radius-length" });
 });

package/src/actions/charts/raincloud.js

@@ -376,7 +376,7 @@ function raincloudOwner(program, requested) {
   throw new Error("editRaincloudPlot target is ambiguous; provide target.");
 }
 
-export const createRaincloudPlot = action(
+export const createRaincloudPlot = /* @__PURE__ */ action(
   { op: "createRaincloudPlot", description: "Create a half-density, summary, and raw-point distribution plot." },
   function (args = {}) {
     const operation = "createRaincloudPlot";
@@ -385,7 +385,7 @@ export const createRaincloudPlot = action(
   }
 );
 
-export const editRaincloudPlot = action(
+export const editRaincloudPlot = /* @__PURE__ */ action(
   { op: "editRaincloudPlot", description: "Revise one Raincloud plot's shared source and statistical roles." },
   function (args = {}) {
     const operation = "editRaincloudPlot";

package/src/actions/charts/rug-strip.js

@@ -1,4 +1,5 @@
 import { action } from "../../core/action.js";
+import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validateNonEmptyString, validateNonNegativeFinite, validateOptionObject } from
   "../../core/validation.js";
@@ -19,12 +20,15 @@ import {
 
 const RUG_OPTIONS = Object.freeze(["id", "data", "coordinate", "x", "y", "edge", "tick", "guides"]);
 const MEASURE_OPTIONS = Object.freeze(["field", "fieldType", "temporalUnit", "scale"]);
-const TICK_OPTIONS = Object.freeze(["length", "stroke", "strokeWidth", "opacity"]);
+const TICK_OPTIONS = Object.freeze([
+  "length", "stroke", "strokeWidth", "opacity", ...STROKE_STYLE_PROPERTIES
+]);
 const STRIP_OPTIONS = Object.freeze([
   "id", "data", "coordinate", "x", "y", "color", "size", "shape", "point", "jitter", "guides"
 ]);
 const POINT_OPTIONS = Object.freeze([
-  "radius", "shape", "fill", "opacity", "stroke", "strokeWidth"
+  "radius", "shape", "fill", "opacity", "stroke", "strokeWidth",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 const JITTER_OPTIONS = Object.freeze(["maxOffset", "seed", "key"]);
 
@@ -75,7 +79,7 @@ function normalizeRugGuides(value, measure, operation) {
   return { axes, grid, legend: false };
 }
 
-export const createRugPlot = action(
+export const createRugPlot = /* @__PURE__ */ action(
   {
     op: "createRugPlot",
     description: "Create a one-dimensional Rug plot at an explicit plot edge."
@@ -202,7 +206,7 @@ function normalizeStripGuides(value, actualChannels, hasLegend, operation) {
   return { axes, grid, legend };
 }
 
-export const createStripPlot = action(
+export const createStripPlot = /* @__PURE__ */ action(
   {
     op: "createStripPlot",
     description: "Create a one-dimensional Strip plot with an optional categorical slot and jitter."

package/src/actions/charts/scatter.js

@@ -1,5 +1,6 @@
 import { action } from "../../core/action.js";
 import { validateNonNegativeFinite } from "../../core/validation.js";
+import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
   applyFacadeGuides,
   normalizeAppearance,
@@ -18,10 +19,11 @@ const OPTIONS = Object.freeze([
   "point", "guides"
 ]);
 const POINT_OPTIONS = Object.freeze([
-  "shape", "fill", "opacity", "stroke", "strokeWidth", "radius"
+  "shape", "fill", "opacity", "stroke", "strokeWidth", "radius",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 
-export const createScatterPlot = action(
+export const createScatterPlot = /* @__PURE__ */ action(
   {
     op: "createScatterPlot",
     description: "Create a Cartesian scatter plot from existing chart data."

package/src/actions/composition/actions.js

@@ -1,4 +1,5 @@
-import { action } from "../../core/action.js";
+import { inheritTextMetrics } from "../textMetrics/index.js";
+import { action, closedAction } from "../../core/action.js";
 import { ChartProgram as CoreChartProgram } from "../../core/ChartProgram.js";
 import { freezeOwned, isPlainObject } from "../../core/immutable.js";
 import { validateUserId } from "../../core/identifiers.js";
@@ -12,6 +13,7 @@ import { namespaceGraphicSnapshot } from "../../materialization/compositionSnaps
 import { materializeCompositionGraphics } from
   "../../materialization/composition.js";
 import { materializeFacetGraphics } from "../../materialization/facets.js";
+import { replayInheritedThemeFrames } from "../theme/composition.js";
 
 const CONCAT_OPTIONS = Object.freeze([
   "id", "programs", "gap", "align", "padding"
@@ -115,7 +117,7 @@ export function applyCompositionState(program, state, tracedChildren = []) {
   return next.materializeComposition();
 }
 
-const useProgram = action(
+const useProgram = /* @__PURE__ */ action(
   {
     op: "useProgram",
     description: "Retain one named child program in a composition.",
@@ -130,7 +132,7 @@ const useProgram = action(
   }
 );
 
-const materializeComposition = action(
+const materializeComposition = /* @__PURE__ */ action(
   {
     op: "materializeComposition",
     description: "Materialize retained child programs into one graphic tree.",
@@ -158,17 +160,16 @@ function concatAction(direction, op) {
   );
 }
 
-export const hconcatAction = concatAction("horizontal", "hconcat");
-export const vconcatAction = concatAction("vertical", "vconcat");
+export const hconcatAction = /* @__PURE__ */ concatAction("horizontal", "hconcat");
+export const vconcatAction = /* @__PURE__ */ concatAction("vertical", "vconcat");
 
-const editCompositionLayout = action(
+const editCompositionLayout = /* @__PURE__ */ closedAction(
   {
     op: "editCompositionLayout",
     description: "Edit composition layout.",
     scope: "composition"
-  },
+  }, LAYOUT_EDIT_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, LAYOUT_EDIT_OPTIONS, "editCompositionLayout");
     if (!LAYOUT_EDIT_OPTIONS.some(option => Object.hasOwn(args, option))) {
       throw new TypeError("editCompositionLayout requires at least one layout option.");
     }
@@ -226,14 +227,13 @@ const editCompositionLayout = action(
   }
 );
 
-const replaceCompositionChild = action(
+const replaceCompositionChild = /* @__PURE__ */ closedAction(
   {
     op: "replaceCompositionChild",
     description: "Replace one composition child without changing its slot.",
     scope: "composition"
-  },
+  }, REPLACEMENT_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, REPLACEMENT_OPTIONS, "replaceCompositionChild");
     this._assertCompositionProgram("replaceCompositionChild");
     if (this.compositionSpec.type === "facet") {
       throw new Error("replaceCompositionChild is not available on a facet composition.");
@@ -245,10 +245,14 @@ const replaceCompositionChild = action(
     if (!(args.program instanceof CoreChartProgram)) {
       throw new TypeError("replaceCompositionChild program must be a ChartProgram.");
     }
-    childDescriptor({ id: target, program: args.program });
+    const replacement = inheritTextMetrics(this, replayInheritedThemeFrames(
+      args.program,
+      this.materializationConfigs.theme
+    ));
+    childDescriptor({ id: target, program: replacement });
     const children = freezeOwned({
       ...this.children,
-      [target]: args.program
+      [target]: replacement
     });
     return applyCompositionState(this, {
       children,
@@ -264,14 +268,13 @@ function requireConcat(program, operation) {
   }
 }
 
-const insertCompositionChild = action(
+const insertCompositionChild = /* @__PURE__ */ closedAction(
   {
     op: "insertCompositionChild",
     description: "Insert one named child into a concat composition.",
     scope: "composition"
-  },
+  }, INSERTION_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, INSERTION_OPTIONS, "insertCompositionChild");
     requireConcat(this, "insertCompositionChild");
     const id = validateUserId(args.id, "Composition child ID");
     if (Object.hasOwn(this.children, id)) {
@@ -283,7 +286,11 @@ const insertCompositionChild = action(
     if (args.before !== undefined && args.after !== undefined) {
       throw new Error("insertCompositionChild before and after are mutually exclusive.");
     }
-    childDescriptor({ id, program: args.program });
+    const inserted = inheritTextMetrics(this, replayInheritedThemeFrames(
+      args.program,
+      this.materializationConfigs.theme
+    ));
+    childDescriptor({ id, program: inserted });
     const order = [...this.compositionSpec.children];
     if (args.before !== undefined || args.after !== undefined) {
       const property = args.before !== undefined ? "before" : "after";
@@ -295,20 +302,19 @@ const insertCompositionChild = action(
       order.push(id);
     }
     return applyCompositionState(this, {
-      children: freezeOwned({ ...this.children, [id]: args.program }),
+      children: freezeOwned({ ...this.children, [id]: inserted }),
       compositionSpec: { ...this.compositionSpec, children: order }
     }, [id]);
   }
 );
 
-const removeCompositionChild = action(
+const removeCompositionChild = /* @__PURE__ */ closedAction(
   {
     op: "removeCompositionChild",
     description: "Remove one named child from a concat composition.",
     scope: "composition"
-  },
+  }, REMOVAL_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, REMOVAL_OPTIONS, "removeCompositionChild");
     requireConcat(this, "removeCompositionChild");
     const target = validateUserId(args.target, "Composition child target");
     if (!Object.hasOwn(this.children, target)) {
@@ -329,14 +335,13 @@ const removeCompositionChild = action(
   }
 );
 
-const reorderCompositionChildren = action(
+const reorderCompositionChildren = /* @__PURE__ */ closedAction(
   {
     op: "reorderCompositionChildren",
     description: "Reorder every named child in a concat composition.",
     scope: "composition"
-  },
+  }, REORDER_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, REORDER_OPTIONS, "reorderCompositionChildren");
     requireConcat(this, "reorderCompositionChildren");
     if (!Array.isArray(args.order) || args.order.length === 0 ||
         args.order.some(id => typeof id !== "string" || id.length === 0)) {

package/src/actions/coordinates/actions.js

@@ -31,7 +31,7 @@ function validateLayers(program, layers) {
   return ids;
 }
 
-export const createCoordinate = action(
+export const createCoordinate = /* @__PURE__ */ action(
   {
     op: "createCoordinate",
     description: "Create a semantic coordinate and attach layers to it."
@@ -81,6 +81,6 @@ export const createCoordinate = action(
   }
 );
 
-export function registerCoordinateActions(ProgramClass) {
+export function registerBasicCoordinateActions(ProgramClass) {
   ProgramClass.prototype.createCoordinate = createCoordinate;
 }

package/src/actions/coordinates/edit.js

@@ -0,0 +1,76 @@
+import { action } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+import { validateOptionObject } from "../../core/validation.js";
+import { normalizeCoordinateAspect } from "../../grammar/coordinates.js";
+import { normalizePolarFrameOptions } from "../../grammar/polar.js";
+import {
+  applyMaterializationPlan,
+  planCoordinateRematerialization
+} from "../../materialization/dependencies.js";
+import { requireCoordinate } from "../../selectors/coordinates.js";
+
+const EDIT_COORDINATE_OPTIONS = Object.freeze(["target", "aspect", "polarFrame"]);
+
+function applyCoordinatePatch(program, target, property, value) {
+  const coordinate = requireCoordinate(program, target);
+  if (value === "auto") {
+    return coordinate[property] === undefined
+      ? program
+      : program.editSemantic({
+          property: `coordinate[${target}].${property}`,
+          remove: true
+        });
+  }
+  return program.editSemantic({
+    property: `coordinate[${target}].${property}`,
+    value
+  });
+}
+
+export const editCoordinate = /* @__PURE__ */ action(
+  {
+    op: "editCoordinate",
+    description: "Edit coordinate layout constraints and rematerialize its consumers."
+  },
+  function (args = {}) {
+    validateOptionObject(args, EDIT_COORDINATE_OPTIONS, "editCoordinate", {
+      allowEmpty: false,
+      emptyMessage: "editCoordinate requires aspect or polarFrame changes.",
+      emptyError: Error
+    });
+    const target = validateUserId(args.target, "Coordinate id");
+    const coordinate = requireCoordinate(this, target);
+    const hasAspect = Object.hasOwn(args, "aspect");
+    const hasPolarFrame = Object.hasOwn(args, "polarFrame");
+    if (!hasAspect && !hasPolarFrame) {
+      throw new Error("editCoordinate requires aspect or polarFrame changes.");
+    }
+    const aspect = hasAspect ? normalizeCoordinateAspect(args.aspect) : undefined;
+    if (hasPolarFrame && coordinate.type !== "polar") {
+      throw new Error("editCoordinate polarFrame requires a Polar coordinate.");
+    }
+    const polarFrame = hasPolarFrame
+      ? normalizePolarFrameOptions(args.polarFrame)
+      : undefined;
+    let proposed = this;
+    if (hasAspect) {
+      proposed = applyCoordinatePatch(proposed, target, "aspect", aspect);
+    }
+    if (hasPolarFrame) {
+      proposed = applyCoordinatePatch(
+        proposed,
+        target,
+        "polarFrame",
+        polarFrame
+      );
+    }
+    const plan = planCoordinateRematerialization(proposed, target);
+    // Validate the complete dependent geometry on a discarded immutable branch.
+    applyMaterializationPlan(proposed, plan);
+    return applyMaterializationPlan(proposed, plan);
+  }
+);
+
+export function registerCoordinateEditActions(ProgramClass) {
+  ProgramClass.prototype.editCoordinate = editCoordinate;
+}

package/src/actions/data/basicBin2d.js

@@ -1,6 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
+
 import {
   deriveBin2DRows,
   normalizeBin2DTransform
@@ -11,13 +11,12 @@ const OPTIONS = Object.freeze([
   "id", "source", "x", "y", "bins", "extent", "includeEmpty", "members", "as"
 ]);
 
-export const createBasicBin2DData = action(
+export const createBasicBin2DData = /* @__PURE__ */ closedAction(
   {
     op: "createBin2DData",
     description: "Create immutable rectangular 2D-bin values."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "createBin2DData");
     const owner = validateUserId(args.id, "2D bin dataset id");
     if (this.materializationConfigs.data?.bin2d?.[owner] !== undefined) {
       throw new Error(`2D bin owner "${owner}" already exists.`);