ggaction 0.0.9 → 0.0.11

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

@@ -6,6 +6,7 @@ import {
 } from "../../../../grammar/polarGuides.js";
 import { resolvePlotGraphicPlacement } from
   "../../../../materialization/graphicHierarchy.js";
+import { assertPolarTextLayout } from "../../../../layout/labels.js";
 import {
   formatPolarGuideValues,
   mapPolarGuideValues,
@@ -33,7 +34,7 @@ function labelGeometry(program, kind, config) {
   const frame = resolvePolarFrameForProgram(program);
   const mapped = mapPolarGuideValues(program, config);
   const text = formatPolarGuideValues(program, config, mapped.values);
-  return {
+  const geometry = {
     values: mapped.values,
     text,
     ...(kind === "theta"
@@ -49,6 +50,21 @@ function labelGeometry(program, kind, config) {
           offset: config.offset
         }))
   };
+  assertPolarTextLayout({
+    canvas: program.graphicSpec.objects.canvas,
+    label: `${prefix(kind)} axis labels`,
+    items: text.map((value, index) => ({
+      x: geometry.x[index],
+      y: geometry.y[index],
+      text: value,
+      fontSize: config.fontSize,
+      fontFamily: config.fontFamily,
+      fontWeight: config.fontWeight,
+      textAlign: geometry.textAlign[index],
+      textBaseline: geometry.textBaseline[index]
+    }))
+  });
+  return geometry;
 }
 
 function resolveLabelConfig(program, kind, args, resources, previous) {

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

@@ -1,4 +1,7 @@
-import { validateOptionObject } from "../../../../core/validation.js";
+import {
+  validateGeneratedItemLimit,
+  validateOptionObject
+} from "../../../../core/validation.js";
 import {
   POLAR_AXIS_DEFAULTS,
   resolvePolarGuideResources
@@ -49,6 +52,9 @@ export function validateModeOptions(args, operation) {
   if (Object.hasOwn(args, "count") && Object.hasOwn(args, "values")) {
     throw new Error(`${operation} cannot use count and values together.`);
   }
+  if (Array.isArray(args.values)) {
+    validateGeneratedItemLimit(args.values.length, "Polar guide value count");
+  }
 }
 
 export function validateAngle(value) {

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

@@ -9,6 +9,7 @@ import {
 } from "../../../../grammar/polarGuides.js";
 import { resolvePlotGraphicPlacement } from
   "../../../../materialization/graphicHierarchy.js";
+import { assertPolarTextLayout } from "../../../../layout/labels.js";
 import { inferAxisTitleText } from "../../axes/titles.js";
 import {
   POLAR_AXIS_DEFAULTS,
@@ -39,6 +40,20 @@ function titleGeometry(program, kind, config) {
       });
 }
 
+function validateTitleGeometry(program, kind, config, geometry, text) {
+  assertPolarTextLayout({
+    canvas: program.graphicSpec.objects.canvas,
+    label: `${prefix(kind)} axis title`,
+    items: [{
+      ...geometry,
+      text,
+      fontSize: config.fontSize,
+      fontFamily: config.fontFamily,
+      fontWeight: config.fontWeight
+    }]
+  });
+}
+
 function resolveTitleConfig(kind, args, resources, previous) {
   const config = {
     ...(previous ?? {}),
@@ -96,6 +111,8 @@ function makeEditTitle(kind) {
       : config.inferredText
         ? inferAxisTitleText(this, polarGuideNames(kind).channel, config.scale)
         : this.semanticSpec.guides.axis?.[kind]?.title;
+    const geometry = titleGeometry(this, kind, config);
+    validateTitleGeometry(this, kind, config, geometry, text);
     let next = this;
     if (text !== this.semanticSpec.guides.axis?.[kind]?.title) {
       next = next.editSemantic({
@@ -103,7 +120,6 @@ function makeEditTitle(kind) {
         value: text
       });
     }
-    const geometry = titleGeometry(next, kind, config);
     next = next._withGuideConfig(kind, "title", config);
     const properties = {
       ...geometry,
@@ -138,7 +154,8 @@ function makeCreateTitle(kind) {
       args.text ?? inferAxisTitleText(this, names.channel, resources.scale),
       "Polar axis title text"
     );
-    titleGeometry(this, kind, config);
+    const geometry = titleGeometry(this, kind, config);
+    validateTitleGeometry(this, kind, config, geometry, text);
     let next = withAxisSemantics(this, kind, resources);
     if (kind === "radius" &&
         next.guideConfigs.axis?.radius?.layout === undefined) {

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

@@ -1,6 +1,7 @@
 import { action } from "../../../core/action.js";
 import {
   noOptions,
+  validateGeneratedItemLimit,
   validateOptionObject,
   validateNonEmptyString,
   validateNonNegativeFinite
@@ -55,6 +56,9 @@ function validateOptions(args, operation, create) {
   if (Object.hasOwn(args, "count") && Object.hasOwn(args, "values")) {
     throw new Error(`${operation} cannot use count and values together.`);
   }
+  if (Array.isArray(args.values)) {
+    validateGeneratedItemLimit(args.values.length, "Polar grid value count");
+  }
   if (Object.hasOwn(args, "color")) {
     validateNonEmptyString(args.color, "Polar grid color");
   }

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

@@ -1,5 +1,6 @@
 import { validateUserId } from "../../../core/identifiers.js";
 import {
+  validateGeneratedItemLimit,
   validateNonEmptyString,
   validateNonNegativeFinite,
   validatePositiveFinite
@@ -174,6 +175,7 @@ export function resolvePolarTickValues(program, config) {
     if (config.mode !== "values") {
       throw new Error("Discrete theta guides require explicit or inferred values.");
     }
+    validateGeneratedItemLimit(config.values.length, "Polar guide value count");
     const domain = new Set(scale.domain);
     if (!config.values.every(value => domain.has(value))) {
       throw new RangeError("Polar guide values must be inside the scale domain.");
@@ -181,6 +183,7 @@ export function resolvePolarTickValues(program, config) {
     return config.values;
   }
   const values = valuesFromTickConfig(program, config);
+  validateGeneratedItemLimit(values.length, "Polar guide value count");
   const low = Math.min(...scale.domain);
   const high = Math.max(...scale.domain);
   if (!values.every(value => value >= low && value <= high)) {
@@ -238,6 +241,9 @@ export function validatePolarTickConfig(config, label) {
       (!Number.isInteger(config.count) || config.count <= 0)) {
     throw new RangeError(`${label} count must be a positive integer.`);
   }
+  if (config.mode === "count") {
+    validateGeneratedItemLimit(config.count, `${label} count`);
+  }
   if (config.mode === "values" && (
     !Array.isArray(config.values) || config.values.length === 0 ||
     !config.values.every(value =>

package/src/actions/index.js

@@ -1,23 +1,23 @@
-import { registerCanvasActions } from "./canvas/index.js";
-import { registerChartActions } from "./charts/index.js";
-import { registerCategoryOrderActions } from "./categoryOrder/index.js";
-import { registerCoordinateActions } from "./coordinates/actions.js";
-import { registerCompositionActions } from "./composition/index.js";
+import { registerPrimitiveActions } from "./primitives/index.js";
+import { registerSelectionActions } from "./selection/index.js";
 import { registerDataActions } from "./data/index.js";
+import { registerCategoryOrderActions } from "./categoryOrder/index.js";
 import { registerEncodingActions } from "./encodings/index.js";
-import { registerErrorBandActions } from "./errorBands/index.js";
-import { registerErrorBarActions } from "./errorBars/index.js";
+import { registerScaleActions } from "./scales/index.js";
+import { registerMarkActions } from "./marks/index.js";
+import { registerCoordinateActions } from "./coordinates/actions.js";
 import { registerFacetActions } from "./facets/index.js";
-import { registerBoxPlotActions } from "./boxPlots/index.js";
+import { registerCompositionActions } from "./composition/index.js";
+import { registerTitleActions } from "./titles/index.js";
+import { registerCanvasActions } from "./canvas/index.js";
 import { registerGuideActions } from "./guides/index.js";
 import { registerGradientPlotActions } from "./gradientPlots/index.js";
-import { registerMarkActions } from "./marks/index.js";
-import { registerPrimitiveActions } from "./primitives/index.js";
+import { registerBoxPlotActions } from "./boxPlots/index.js";
+import { registerErrorBarActions } from "./errorBars/index.js";
 import { registerRegressionActions } from "./regression/index.js";
-import { registerScaleActions } from "./scales/index.js";
-import { registerTitleActions } from "./titles/index.js";
-import { registerSelectionActions } from "./selection/index.js";
 import { registerViolinPlotActions } from "./violinPlots/index.js";
+import { registerErrorBandActions } from "./errorBands/index.js";
+import { registerChartActions } from "./charts/index.js";
 
 export function registerActions(ProgramClass) {
   registerPrimitiveActions(ProgramClass);

package/src/actions/intervals/resolve.js

@@ -3,37 +3,28 @@ import {
   resolveOptionalUserId,
   validateUserId
 } from "../../core/identifiers.js";
+import {
+  validateNonEmptyString as requireField,
+  validateOptionObject
+} from "../../core/validation.js";
 import { readQuantitativeField } from "../../grammar/scales/index.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { hasLayer, resolveEligibleLayer } from "../../selectors/layers.js";
 import { findSemanticScale } from "../../selectors/scales.js";
 
-const CHANNEL_OPTIONS = Object.freeze([
+const CHANNEL_OPTIONS = [
   "field", "fieldType", "scale", "center", "extent", "level", "lower", "upper"
-]);
-const INTERVAL_PARAMETER_KEYS = Object.freeze([
-  "center", "extent", "level", "lower", "upper"
-]);
-const FIELD_TYPES = Object.freeze([
+];
+const INTERVAL_PARAMETER_KEYS = CHANNEL_OPTIONS.slice(3);
+const POSITION_CHANNELS = ["x", "y"];
+const FIELD_TYPES = [
   "quantitative", "temporal", "ordinal", "nominal"
-]);
+];
 
 function requireObject(value, label) {
-  if (!isPlainObject(value)) {
-    throw new TypeError(`${label} must be a plain object.`);
-  }
-  const unknown = Object.keys(value).find(key => !CHANNEL_OPTIONS.includes(key));
-  if (unknown !== undefined) {
-    throw new Error(`Unknown ${label} option "${unknown}".`);
-  }
-  return value;
-}
-
-function requireField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
+  return validateOptionObject(value, CHANNEL_OPTIONS, label, {
+    plainObjectMessage: `${label} must be a plain object.`
+  });
 }
 
 function hasCompleteFieldPositions(layer) {
@@ -42,65 +33,30 @@ function hasCompleteFieldPositions(layer) {
   return (
     typeof layer.data === "string" &&
     typeof layer.coordinate === "string" &&
-    typeof x?.field === "string" &&
-    typeof y?.field === "string" &&
-    typeof x.scale === "string" &&
-    typeof y.scale === "string" &&
-    FIELD_TYPES.includes(x.fieldType) &&
-    FIELD_TYPES.includes(y.fieldType)
+    [x, y].every(encoding =>
+      typeof encoding?.field === "string" &&
+      typeof encoding.scale === "string" &&
+      FIELD_TYPES.includes(encoding.fieldType)
+    )
   );
 }
 
-function resolveSourceLayer(program, args, operation) {
-  if (args.target === undefined && args.x !== undefined && args.y !== undefined) {
-    return undefined;
-  }
-  const target = args.target === undefined
-    ? undefined
-    : validateUserId(args.target, `${operation} source layer id`);
-  return resolveEligibleLayer(program, {
-    target,
-    predicate: hasCompleteFieldPositions,
-    label: operation
-  });
-}
-
-function resolveDataset(program, args, sourceLayer, operation, resourceLabel) {
-  const requested = args.data ?? sourceLayer?.data ?? program.context.currentData;
-  let dataset;
-  if (requested !== undefined) {
-    const id = validateUserId(requested, `${resourceLabel} dataset id`);
-    dataset = findDataset(program, id);
-    if (dataset === undefined) {
-      throw new Error(`Unknown ${resourceLabel} dataset "${id}".`);
-    }
-  } else if (program.semanticSpec.datasets.length === 1) {
-    dataset = program.semanticSpec.datasets[0];
-  }
-  if (dataset === undefined) {
-    throw new Error(`${operation} requires data or one uniquely inferable dataset.`);
-  }
-  if (sourceLayer !== undefined && dataset.id !== sourceLayer.data) {
-    throw new Error(
-      `${operation} data must match source layer "${sourceLayer.id}" data "${sourceLayer.data}".`
-    );
-  }
-  return dataset;
-}
-
 function scaleOptions(program, value, inferredId, defaults = {}) {
   if (value !== undefined && !isPlainObject(value)) {
     throw new TypeError("Interval scale must be a plain object.");
   }
   const id = value?.id ?? inferredId;
-  const usesExisting = id !== undefined && findSemanticScale(program, id) !== undefined;
-  return {
-    ...(usesExisting ? {} : defaults),
+  const scale = {
+    ...(id !== undefined && findSemanticScale(program, id) !== undefined
+      ? {}
+      : defaults),
     ...(value ?? {}),
     ...(value?.id === undefined && inferredId !== undefined
       ? { id: inferredId }
       : {})
   };
+  if (value?.type === "log" && value.zero === undefined) delete scale.zero;
+  return scale;
 }
 
 function hasAny(value, keys) {
@@ -113,30 +69,28 @@ function resolveIntervalChannel(channels, sourceLayer, {
   defaultIntervalChannel,
   ambiguousMessage
 }) {
-  const explicitBounds = ["x", "y"].filter(channel =>
-    hasAny(channels[channel], ["lower", "upper"])
-  );
-  if (explicitBounds.length > 1) {
-    throw new Error(`${operation} requires exactly one interval channel.`);
+  for (const hints of [
+    ["lower", "upper"],
+    ["center", "extent", "level"]
+  ]) {
+    const hinted = POSITION_CHANNELS.filter(channel =>
+      hasAny(channels[channel], hints)
+    );
+    if (hinted.length > 1) {
+      throw new Error(`${operation} requires exactly one interval channel.`);
+    }
+    if (hinted.length === 1) return hinted[0];
   }
-  if (explicitBounds.length === 1) return explicitBounds[0];
 
-  const statisticalHints = ["x", "y"].filter(channel =>
-    hasAny(channels[channel], ["center", "extent", "level"])
-  );
-  if (statisticalHints.length > 1) {
-    throw new Error(`${operation} requires exactly one interval channel.`);
+  const effectiveTypes = {};
+  for (const channel of POSITION_CHANNELS) {
+    effectiveTypes[channel] = channels[channel]?.fieldType ??
+      sourceLayer?.encoding?.[channel]?.fieldType;
   }
-  if (statisticalHints.length === 1) return statisticalHints[0];
-
-  const effectiveTypes = Object.fromEntries(["x", "y"].map(channel => [
-    channel,
-    channels[channel]?.fieldType ?? sourceLayer?.encoding?.[channel]?.fieldType
-  ]));
-  const quantitative = ["x", "y"].filter(channel =>
+  const quantitative = POSITION_CHANNELS.filter(channel =>
     effectiveTypes[channel] === "quantitative"
   );
-  const positional = ["x", "y"].filter(channel =>
+  const positional = POSITION_CHANNELS.filter(channel =>
     positionTypes.includes(effectiveTypes[channel])
   );
   if (quantitative.length === 1) {
@@ -224,10 +178,11 @@ function resolveInterval(program, channel, explicit, inferred, dataset, {
       lower: requireField(explicit.lower, `${operation} ${channel} lower`),
       upper: requireField(explicit.upper, `${operation} ${channel} upper`)
     };
-    if (new Set(Object.values(fields)).size !== 3) {
+    const fieldValues = Object.values(fields);
+    if (new Set(fieldValues).size !== 3) {
       throw new Error("Explicit interval center, lower, and upper fields must be distinct.");
     }
-    for (const field of Object.values(fields)) {
+    for (const field of fieldValues) {
       readQuantitativeField(dataset.values, field);
     }
     return { channel, mode: "explicit", fields, scale, title: fields.center };
@@ -268,39 +223,46 @@ function resolveGrouping(args, sourceLayer, independentField, mode, {
   };
 }
 
-function resolveOwner(program, requested, {
-  defaultId,
-  ownerLabel,
-  operation
-}) {
-  const defaultOccupied = hasLayer(program, defaultId) ||
-    program.graphicSpec.objects[defaultId] !== undefined ||
-    findDataset(program, `${defaultId}IntervalData`) !== undefined;
-  return resolveOptionalUserId(requested, {
-    defaultId,
-    label: ownerLabel,
-    operation,
-    ambiguous: defaultOccupied
-  });
-}
-
 export function resolveIntervalComposite(program, args, policy) {
+  const { operation, resourceLabel } = policy;
   const channels = {
     x: args.x === undefined
       ? undefined
-      : requireObject(args.x, `${policy.operation} x`),
+      : requireObject(args.x, `${operation} x`),
     y: args.y === undefined
       ? undefined
-      : requireObject(args.y, `${policy.operation} y`)
+      : requireObject(args.y, `${operation} y`)
   };
-  const sourceLayer = resolveSourceLayer(program, args, policy.operation);
-  const dataset = resolveDataset(
-    program,
-    args,
-    sourceLayer,
-    policy.operation,
-    policy.resourceLabel
-  );
+  let sourceLayer;
+  if (!(args.target === undefined && args.x !== undefined && args.y !== undefined)) {
+    const target = args.target === undefined
+      ? undefined
+      : validateUserId(args.target, `${operation} source layer id`);
+    sourceLayer = resolveEligibleLayer(program, {
+      target,
+      predicate: hasCompleteFieldPositions,
+      label: operation
+    });
+  }
+  const requested = args.data ?? sourceLayer?.data ?? program.context.currentData;
+  let dataset;
+  if (requested !== undefined) {
+    const dataId = validateUserId(requested, `${resourceLabel} dataset id`);
+    dataset = findDataset(program, dataId);
+    if (dataset === undefined) {
+      throw new Error(`Unknown ${resourceLabel} dataset "${dataId}".`);
+    }
+  } else if (program.semanticSpec.datasets.length === 1) {
+    dataset = program.semanticSpec.datasets[0];
+  }
+  if (dataset === undefined) {
+    throw new Error(`${operation} requires data or one uniquely inferable dataset.`);
+  }
+  if (sourceLayer !== undefined && dataset.id !== sourceLayer.data) {
+    throw new Error(
+      `${operation} data must match source layer "${sourceLayer.id}" data "${sourceLayer.data}".`
+    );
+  }
   const intervalChannel = resolveIntervalChannel(channels, sourceLayer, policy);
   const positionChannel = intervalChannel === "x" ? "y" : "x";
   const position = resolvePosition(
@@ -318,7 +280,15 @@ export function resolveIntervalComposite(program, args, policy) {
     dataset,
     policy
   );
-  const id = resolveOwner(program, args.id, policy);
+  const defaultId = policy.defaultId;
+  const id = resolveOptionalUserId(args.id, {
+    defaultId,
+    label: policy.ownerLabel,
+    operation,
+    ambiguous: hasLayer(program, defaultId) ||
+      program.graphicSpec.objects[defaultId] !== undefined ||
+      findDataset(program, `${defaultId}IntervalData`) !== undefined
+  });
   const generatedFields = {
     center: `__${id}_center`,
     lower: `__${id}_lower`,
@@ -340,7 +310,7 @@ export function resolveIntervalComposite(program, args, policy) {
     dataId: interval.mode === "statistical" ? `${id}IntervalData` : dataset.id,
     coordinate: validateUserId(
       args.coordinate ?? sourceLayer?.coordinate ?? "main",
-      `${policy.resourceLabel} coordinate id`
+      `${resourceLabel} coordinate id`
     ),
     orientation: intervalChannel === "y" ? "vertical" : "horizontal",
     position,

package/src/actions/marks/arc/actions.js

@@ -10,7 +10,10 @@ import { buildAnnularSectorCommands } from "../../../grammar/polarPaths.js";
 import { resolvePolarFrame } from "../../../grammar/polar.js";
 import { mapOrdinalValues } from "../../../grammar/scales/index.js";
 import { resolveGraphicBounds } from "../../../layout/canvas.js";
-import { canMaterializeArc } from "../../../materialization/marks/index.js";
+import {
+  canMaterializeArc,
+  getSourceDependentMarkSteps
+} from "../../../materialization/marks/index.js";
 import { findDataset } from "../../../selectors/datasets.js";
 import { findLayer, resolveEligibleLayer } from "../../../selectors/layers.js";
 import { DEFAULT_COLORS } from "../../../theme/defaults.js";
@@ -20,6 +23,7 @@ import { rematerializeHighlightBaseline } from "../lifecycle.js";
 import {
   assertMarkAvailable,
   applyLayeredMarkInheritance,
+  editMarkGraphic,
   materializeInheritedMark,
   resolveLayeredMarkInheritance,
   resolveMarkData,
@@ -27,14 +31,11 @@ import {
   validateMarkOptions
 } from "../shared.js";
 
-const CREATE_OPTIONS = Object.freeze([
-  "id", "data", "innerRadius", "padAngle", "fill", "opacity", "stroke",
-  "strokeWidth"
-]);
-const EDIT_OPTIONS = Object.freeze([
-  "target", "innerRadius", "padAngle", "fill", "opacity", "stroke",
-  "strokeWidth"
+const ARC_OPTIONS = Object.freeze([
+  "innerRadius", "padAngle", "fill", "opacity", "stroke", "strokeWidth"
 ]);
+const CREATE_OPTIONS = Object.freeze(["id", "data", ...ARC_OPTIONS]);
+const EDIT_OPTIONS = Object.freeze(["target", ...ARC_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
 
 function validateInnerRadius(value) {
@@ -170,15 +171,15 @@ const rematerializeArcMark = action(
       resolved = resolved.rematerializeScale({ id: colorScaleId });
     }
     const config = resolved.markConfigs[id] ?? {};
+    const frame = resolvePolarFrame(resolveGraphicBounds(resolved));
     const derived = deriveArcSectors(dataset.values, layer, {
       thetaScale: resolved.resolvedScales[thetaScaleId],
       ...(radiusScaleId === undefined
         ? {}
         : { radiusScale: resolved.resolvedScales[radiusScaleId] }),
-      frame: resolvePolarFrame(resolveGraphicBounds(resolved)),
+      frame,
       innerRadiusRatio: config.innerRadius ?? 0
     });
-    const frame = resolvePolarFrame(resolveGraphicBounds(resolved));
     const commands = derived.sectors.map(sector => buildAnnularSectorCommands({
       frame,
       startTheta: sector.startTheta,
@@ -194,26 +195,15 @@ const rematerializeArcMark = action(
           resolved.resolvedScales[colorScaleId].domain,
           resolved.resolvedScales[colorScaleId].range
         );
-    return resolved
-      .editGraphics({ target: id, property: "length", value: commands.length })
-      .editGraphics({ target: id, property: "commands", value: commands })
-      .editGraphics({ target: id, property: "fill", value: fills })
-      .editGraphics({ target: id, property: "opacity", value: config.opacity ?? 1 })
-      .editGraphics({
-        target: id,
-        property: "stroke",
-        value: config.stroke === false ? "transparent" : config.stroke ?? "#ffffff"
-      })
-      .editGraphics({
-        target: id,
-        property: "strokeWidth",
-        value: config.stroke === false ? 0 : config.strokeWidth ?? 1
-      })
-      .editGraphics({
-        target: id,
-        property: "strokeDash",
-        value: commands.map(() => [])
-      });
+    return editMarkGraphic(resolved, id, {
+      length: commands.length,
+      commands,
+      fill: fills,
+      opacity: config.opacity ?? 1,
+      stroke: config.stroke === false ? "transparent" : config.stroke ?? "#ffffff",
+      strokeWidth: config.stroke === false ? 0 : config.strokeWidth ?? 1,
+      strokeDash: commands.map(() => [])
+    });
   }
 );
 
@@ -258,14 +248,19 @@ const editArcMark = action(
         allowStrokeRemoval: true
       })
     );
-    return canMaterializeArc(next, layer)
-      ? next.rematerializeArcMark({ id: layer.id })
-      : next;
+    if (!canMaterializeArc(next, layer)) return next;
+    let rematerialized = next.rematerializeArcMark({ id: layer.id });
+    for (const step of getSourceDependentMarkSteps(rematerialized, layer.id)) {
+      rematerialized = rematerialized[step.op](step.args);
+    }
+    return rematerialized;
   }
 );
 
 export function registerArcMarkActions(ProgramClass) {
-  ProgramClass.prototype.createArcMark = createArcMark;
-  ProgramClass.prototype.editArcMark = editArcMark;
-  ProgramClass.prototype.rematerializeArcMark = rematerializeArcMark;
+  Object.assign(ProgramClass.prototype, {
+    createArcMark,
+    editArcMark,
+    rematerializeArcMark
+  });
 }