ggaction 0.0.12 → 0.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ggaction",
-  "version": "0.0.12",
+  "version": "0.0.15",
   "description": "Build charts through immutable, traceable graphical actions.",
   "license": "MIT",
   "author": "Hyeon Jeon",
@@ -111,18 +111,25 @@
     "docs:signatures:check": "node scripts/generate-doc-signatures.js --check",
     "examples:index": "node scripts/generate-examples-readme.js",
     "examples:index:check": "node scripts/generate-examples-readme.js --check",
-    "docs:generate": "npm run examples:index && npm run docs:reference && npm run contracts:cards && npm run docs:actions && npm run docs:signatures && npm run docs:capabilities && npm run docs:metadata && npm run docs:search && npm run docs:images && npm run docs:machine && npm run docs:llms",
+    "docs:generate": "npm run docs:provenance && npm run docs:workflows && npm run examples:index && npm run docs:capabilities && npm run docs:reference && npm run contracts:relations && npm run contracts:cards && npm run docs:picker && npm run docs:scale-editors && npm run docs:actions && npm run docs:signatures && npm run docs:snippets && npm run docs:metadata && npm run docs:search && npm run docs:images && npm run docs:machine && npm run docs:llms",
     "docs:build": "bundle exec jekyll build --source docs --destination _site --baseurl /ggaction",
     "docs:verify": "npm run docs:preflight && npm run docs:generate && npm run test:docs && npm run docs:build && npm run test:docs:built && npm run test:docs:browser",
     "contracts:catalog": "node scripts/generate-action-catalog.js",
     "contracts:catalog:check": "node scripts/generate-action-catalog.js --check",
+    "contracts:relations": "node scripts/generate-action-relationships.js",
+    "contracts:relations:check": "node scripts/generate-action-relationships.js --check",
     "contracts:cards": "node scripts/generate-action-cards.js",
     "contracts:cards:check": "node scripts/generate-action-cards.js --check",
     "package:check": "node scripts/package-artifact.js --check",
     "package:pack": "node scripts/package-artifact.js --pack",
     "package:bundle": "node scripts/measure-browser-bundle.js",
     "test:package": "node scripts/package-consumer.js",
-    "release:notes": "node scripts/release-notes.js"
+    "release:notes": "node scripts/release-notes.js",
+    "docs:workflows": "node scripts/generate-doc-workflows.js",
+    "docs:provenance": "node scripts/doc-provenance.js",
+    "docs:picker": "node scripts/generate-doc-chart-picker.js",
+    "docs:snippets": "node scripts/generate-doc-snippet-contracts.js",
+    "docs:scale-editors": "node scripts/generate-doc-scale-editors.js"
   },
   "engines": {
     "node": ">=20"

package/src/actions/basic.js

@@ -1,21 +1,23 @@
 import { registerBasicCanvasActions } from "./canvas/index.js";
 import { registerBasicChartActions } from "./charts/basic.js";
-import { registerCoordinateActions } from "./coordinates/actions.js";
+import { registerBasicCoordinateActions } from "./coordinates/actions.js";
 import { registerBasicDataActions } from "./data/basic.js";
 import { registerBasicEncodingActions } from "./encodings/basic.js";
 import { registerBasicGuideActions } from "./guides/basic.js";
 import { registerBasicMarkActions } from "./marks/basic.js";
 import { registerBasicPrimitiveActions } from "./primitives/index.js";
 import { registerBasicScaleActions } from "./scales/index.js";
+import { registerThemeActions } from "./theme/index.js";
 
 export function registerBasicActions(ProgramClass) {
+  registerThemeActions(ProgramClass);
   registerBasicPrimitiveActions(ProgramClass);
   registerBasicCanvasActions(ProgramClass);
   registerBasicDataActions(ProgramClass);
   registerBasicMarkActions(ProgramClass);
   registerBasicScaleActions(ProgramClass);
   registerBasicEncodingActions(ProgramClass);
-  registerCoordinateActions(ProgramClass);
+  registerBasicCoordinateActions(ProgramClass);
   registerBasicGuideActions(ProgramClass);
   registerBasicChartActions(ProgramClass);
 }

package/src/actions/boxPlots/components.js

@@ -1,14 +1,19 @@
 import { action } from "../../core/action.js";
 import { validateKeys } from "../../core/validation.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../grammar/strokeStyle.js";
 
 const MEDIAN_OPTIONS = Object.freeze([
   "id", "owner", "data", "category", "categoryType", "measure",
   "coordinate", "categoryScale", "measureScale", "orientation", "stroke",
-  "strokeWidth"
+  "strokeWidth", ...STROKE_STYLE_PROPERTIES
 ]);
 const OUTLIER_OPTIONS = Object.freeze([
   "id", "data", "category", "categoryType", "measure", "coordinate",
-  "categoryScale", "measureScale", "orientation", "shape", "radius", "opacity"
+  "categoryScale", "measureScale", "orientation", "shape", "radius", "opacity",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 
 export const createBoxMedian = action(
@@ -23,7 +28,11 @@ export const createBoxMedian = action(
     }
     const categoryAction = args.orientation === "vertical" ? "encodeX" : "encodeY";
     const measureAction = args.orientation === "vertical" ? "encodeY" : "encodeX";
-    let next = this.createRuleMark({ id: args.id, data: args.data });
+    let next = this.createRuleMark({
+      id: args.id,
+      data: args.data,
+      ...requestedStrokeDetails(args, "Box median")
+    });
     next = next[categoryAction]({
       target: args.id,
       field: args.category,
@@ -65,7 +74,8 @@ export const createBoxOutliers = action(
       id: args.id,
       data: args.data,
       shape: args.shape,
-      fill: "#111111"
+      fill: "#111111",
+      ...requestedStrokeDetails(args, "Box outlier")
     });
     next = next[categoryAction]({
       target: args.id,

package/src/actions/boxPlots/edit.js

@@ -24,6 +24,8 @@ import {
   resolveBoxWidth
 } from "./options.js";
 import { resolveBoxOrientation } from "./resolve.js";
+import { requestedRectStyleDetails } from "../../grammar/roundedRect.js";
+import { requestedStrokeDetails } from "../../grammar/strokeStyle.js";
 
 const OPTIONS = Object.freeze([
   "target", "data", "x", "y", "whisker", "width", "outliers", "box",
@@ -252,6 +254,8 @@ export const editBoxPlot = action(
       { ...current.outlier, ...outlierPatch },
       "editBoxPlot"
     );
+    const boxStyleDetails = requestedRectStyleDetails(box, "Box body");
+    const medianStyleDetails = requestedStrokeDetails(median, "Box median");
     if (Object.hasOwn(boxPatch, "fill") && owner.encoding?.color !== undefined) {
       throw new Error(
         "editBoxPlot box.fill cannot be combined with a color encoding."
@@ -333,6 +337,7 @@ export const editBoxPlot = action(
           ...next.markConfigs[current.whiskerId],
           errorBar: {
             ...next.markConfigs[current.whiskerId].errorBar,
+            source: summaryRevision.id,
             data: summaryRevision.id
           }
         });
@@ -360,7 +365,10 @@ export const editBoxPlot = action(
           fill: box.fill,
           opacity: box.opacity,
           stroke: box.stroke,
-          strokeWidth: box.strokeWidth
+          strokeWidth: box.strokeWidth,
+          ...(Object.keys(boxStyleDetails).length === 0
+            ? {}
+            : { barAppearance: boxStyleDetails })
         });
         next = updateBoxPositions(next, owner, current, candidate, {
           outlierDataId: outlierRevision?.id,
@@ -385,7 +393,8 @@ export const editBoxPlot = action(
             measureScale: measure.scale,
             shape: outlier.shape,
             radius: outlier.radius,
-            opacity: outlier.opacity
+            opacity: outlier.opacity,
+            ...requestedStrokeDetails(outlier, "Box outlier")
           });
         }
         next = next
@@ -394,12 +403,19 @@ export const editBoxPlot = action(
             target: current.medianId,
             value: median.strokeWidth
           });
+        if (Object.keys(medianStyleDetails).length > 0) {
+          next = next.editRuleMark({
+            target: current.medianId,
+            ...medianStyleDetails
+          });
+        }
         if (findLayer(next, current.outlierId) !== undefined) {
           next = next
             .editPointMark({
               target: current.outlierId,
               shape: outlier.shape,
-              opacity: outlier.opacity
+              opacity: outlier.opacity,
+              ...requestedStrokeDetails(outlier, "Box outlier")
             })
             .encodeRadius({ target: current.outlierId, value: outlier.radius });
         }
@@ -445,7 +461,10 @@ export const editBoxPlot = action(
       fill: box.fill,
       opacity: box.opacity,
       stroke: box.stroke,
-      strokeWidth: box.strokeWidth
+      strokeWidth: box.strokeWidth,
+      ...(Object.keys(boxStyleDetails).length === 0
+        ? {}
+        : { barAppearance: boxStyleDetails })
     });
 
     if (changesBox) next = next.rematerializeBarMark({ id: owner.id });
@@ -456,13 +475,20 @@ export const editBoxPlot = action(
           target: current.medianId,
           value: median.strokeWidth
         });
+      if (Object.keys(medianStyleDetails).length > 0) {
+        next = next.editRuleMark({
+          target: current.medianId,
+          ...medianStyleDetails
+        });
+      }
     }
     if (findLayer(next, current.outlierId) !== undefined && changesOutlier) {
       next = next
         .editPointMark({
           target: current.outlierId,
           shape: outlier.shape,
-          opacity: outlier.opacity
+          opacity: outlier.opacity,
+          ...requestedStrokeDetails(outlier, "Box outlier")
         })
         .encodeRadius({ target: current.outlierId, value: outlier.radius });
     }

package/src/actions/boxPlots/materialize.js

@@ -1,3 +1,4 @@
+import { applyFacadeGuides } from "../charts/shared.js";
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import {
@@ -8,6 +9,8 @@ import {
 import { findDataset } from "../../selectors/datasets.js";
 import { findLayer } from "../../selectors/layers.js";
 import { resolveBoxOrientation } from "./resolve.js";
+import { requestedRectStyleDetails } from "../../grammar/roundedRect.js";
+import { requestedStrokeDetails } from "../../grammar/strokeStyle.js";
 import { resolvePlotGraphicPlacement } from
   "../../materialization/graphicHierarchy.js";
 
@@ -42,6 +45,7 @@ export const materializeBoxPlot = action(
     const whiskerId = `${ownerId}Whisker`;
     const medianId = `${ownerId}Median`;
     const outlierId = `${ownerId}Outliers`;
+    const boxStyleDetails = requestedRectStyleDetails(config.box, "Box body");
     let next = this._withMarkConfig(ownerId, {
       ...this.markConfigs[ownerId],
       boxPlot: {
@@ -60,7 +64,10 @@ export const materializeBoxPlot = action(
       fill: config.box.fill,
       opacity: config.box.opacity,
       stroke: config.box.stroke,
-      strokeWidth: config.box.strokeWidth
+      strokeWidth: config.box.strokeWidth,
+      ...(Object.keys(boxStyleDetails).length === 0
+        ? {}
+        : { barAppearance: boxStyleDetails })
     }).createBoxSummaryData({
       id: summaryId,
       source,
@@ -164,7 +171,8 @@ export const materializeBoxPlot = action(
         categoryScale: category.scale,
         measureScale: measure.scale,
         stroke: config.median.stroke,
-        strokeWidth: config.median.strokeWidth
+        strokeWidth: config.median.strokeWidth,
+        ...requestedStrokeDetails(config.median, "Box median")
       });
     if (hasOutliers) {
       next = next.createBoxOutliers({
@@ -179,7 +187,8 @@ export const materializeBoxPlot = action(
         measureScale: measure.scale,
         shape: config.outlier.shape,
         radius: config.outlier.radius,
-        opacity: config.outlier.opacity
+        opacity: config.outlier.opacity,
+        ...requestedStrokeDetails(config.outlier, "Box outlier")
       });
     }
     next = next._withMarkConfig(ownerId, {
@@ -190,7 +199,7 @@ export const materializeBoxPlot = action(
       }
     });
     if (config.guides !== false) {
-      next = next.createGuides(config.guides);
+      next = applyFacadeGuides(next, config.guides, ownerId);
     }
     return next._withContext({ currentMark: ownerId, currentData: source });
   }

package/src/actions/boxPlots/options.js

@@ -7,6 +7,14 @@ import {
   validateUnitInterval
 } from "../../core/validation.js";
 import { validatePointShape } from "../../grammar/pointShapes.js";
+import {
+  requestedRectStyleDetails,
+  RECT_STYLE_PROPERTIES
+} from "../../grammar/roundedRect.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../grammar/strokeStyle.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
 import { normalizeGuides } from "../charts/shared.js";
 
@@ -45,24 +53,30 @@ function plainOptions(value, keys, label, operation = "createBoxPlot") {
   return value;
 }
 
-function resolveAppearance(value, defaults, label, operation) {
+function resolveAppearance(value, defaults, label, operation, details) {
   const options = plainOptions(
     value,
-    Object.keys(defaults),
+    [
+      ...Object.keys(defaults),
+      ...(details === requestedRectStyleDetails
+        ? RECT_STYLE_PROPERTIES
+        : STROKE_STYLE_PROPERTIES)
+    ],
     label,
     operation
   );
-  return Object.freeze(Object.fromEntries(
-    Object.entries(defaults).map(([key, fallback]) => [
-      key,
-      options[key] === undefined
-        ? fallback
-        : APPEARANCE_VALIDATORS[key](
-            options[key],
-            `createBoxPlot ${label}.${key}`
-          )
-    ])
-  ));
+  return Object.freeze({
+    ...Object.fromEntries(Object.entries(defaults).map(([key, fallback]) => [
+        key,
+        options[key] === undefined
+          ? fallback
+          : APPEARANCE_VALIDATORS[key](
+              options[key],
+              `${operation} ${label}.${key}`
+            )
+      ])),
+    ...details(options, `${operation} ${label}`)
+  });
 }
 
 export function resolveBoxPosition(value, label, operation = "createBoxPlot") {
@@ -122,13 +136,31 @@ export function resolveBoxWidth(value, operation = "createBoxPlot") {
 }
 
 export function resolveBoxAppearance(value, operation = "createBoxPlot") {
-  return resolveAppearance(value, DEFAULT_BOX, "box", operation);
+  return resolveAppearance(
+    value,
+    DEFAULT_BOX,
+    "box",
+    operation,
+    requestedRectStyleDetails
+  );
 }
 
 export function resolveBoxMedianAppearance(value, operation = "createBoxPlot") {
-  return resolveAppearance(value, DEFAULT_MEDIAN, "median", operation);
+  return resolveAppearance(
+    value,
+    DEFAULT_MEDIAN,
+    "median",
+    operation,
+    requestedStrokeDetails
+  );
 }
 
 export function resolveBoxOutlierAppearance(value, operation = "createBoxPlot") {
-  return resolveAppearance(value, DEFAULT_OUTLIER, "outlier", operation);
+  return resolveAppearance(
+    value,
+    DEFAULT_OUTLIER,
+    "outlier",
+    operation,
+    requestedStrokeDetails
+  );
 }

package/src/actions/canvas/actions.js

@@ -161,7 +161,9 @@ export const createBasicCanvas = action(
       background: Object.hasOwn(args, "background")
         ? args.background
         : DEFAULT_CANVAS.background,
-      margin: normalizeMargin(args.margin, DEFAULT_MARGIN),
+      margin: Object.hasOwn(args, "margin")
+        ? normalizeMargin(args.margin, DEFAULT_MARGIN)
+        : DEFAULT_MARGIN,
       size: {
         width: Object.hasOwn(args, "width") ? "explicit" : "auto",
         height: Object.hasOwn(args, "height") ? "explicit" : "auto"

package/src/actions/canvas/fitting.js

@@ -0,0 +1,211 @@
+import { action } from "../../core/action.js";
+import {
+  validateNonNegativeFinite,
+  validatePositiveFinite,
+  validateOptionObject
+} from "../../core/validation.js";
+import { resolveGraphicBounds } from "../../layout/canvas.js";
+import { findCanvasGraphic } from
+  "../../materialization/graphicHierarchy.js";
+
+const OPTIONS = Object.freeze([
+  "padding",
+  "minPlotWidth",
+  "minPlotHeight",
+  "iterationLimit",
+  "overflow"
+]);
+const SIDES = Object.freeze(["top", "right", "bottom", "left"]);
+const DEFAULTS = Object.freeze({
+  padding: 0,
+  minPlotWidth: 160,
+  minPlotHeight: 120,
+  iterationLimit: 32,
+  overflow: "error"
+});
+const UNITS_PER_PIXEL = 4;
+
+function normalizeOptions(args) {
+  validateOptionObject(args, OPTIONS, "fitCanvas", { allowEmpty: true });
+  const policy = { ...DEFAULTS, ...args };
+  validateNonNegativeFinite(policy.padding, "fitCanvas padding");
+  validatePositiveFinite(policy.minPlotWidth, "fitCanvas minPlotWidth");
+  validatePositiveFinite(policy.minPlotHeight, "fitCanvas minPlotHeight");
+  if (!Number.isInteger(policy.iterationLimit) ||
+      policy.iterationLimit <= 0 || policy.iterationLimit > 64) {
+    throw new RangeError(
+      "fitCanvas iterationLimit must be an integer from 1 through 64."
+    );
+  }
+  if (!["error", "report"].includes(policy.overflow)) {
+    throw new Error(`Unsupported fitCanvas overflow policy "${policy.overflow}".`);
+  }
+  return policy;
+}
+
+function probe(program, margin) {
+  try {
+    return { ok: true, program: program.editCanvas({ margin }) };
+  } catch (error) {
+    return {
+      ok: false,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+function marginWith(margin, side, value) {
+  return { ...margin, [side]: value };
+}
+
+function minimizeSide(program, margin, side, policy) {
+  const current = margin[side];
+  const floor = Math.ceil(policy.padding * UNITS_PER_PIXEL) /
+    UNITS_PER_PIXEL;
+  if (floor > current) {
+    const expanded = marginWith(margin, side, floor);
+    const result = probe(program, expanded);
+    return result.ok
+      ? { program: result.program, margin: expanded, iterations: 1, issues: [] }
+      : {
+          program,
+          margin,
+          iterations: 1,
+          issues: [`${side} padding: ${result.message}`]
+        };
+  }
+
+  let low = Math.ceil(policy.padding * UNITS_PER_PIXEL);
+  let high = Math.floor(current * UNITS_PER_PIXEL);
+  if (low > high) {
+    return { program, margin, iterations: 0, issues: [] };
+  }
+
+  const cache = new Map();
+  const test = units => {
+    if (cache.has(units)) return cache.get(units);
+    const result = probe(
+      program,
+      marginWith(margin, side, units / UNITS_PER_PIXEL)
+    );
+    cache.set(units, result);
+    return result;
+  };
+  let iterations = 0;
+  const upper = test(high);
+  iterations += 1;
+  if (!upper.ok) {
+    return { program, margin, iterations, issues: [] };
+  }
+
+  while (low < high && iterations < policy.iterationLimit) {
+    const middle = Math.floor((low + high) / 2);
+    const result = test(middle);
+    iterations += 1;
+    if (result.ok) high = middle;
+    else low = middle + 1;
+  }
+  const best = test(high);
+  const fittedMargin = marginWith(
+    margin,
+    side,
+    high / UNITS_PER_PIXEL
+  );
+  return {
+    program: best.program,
+    margin: fittedMargin,
+    iterations,
+    issues: low === high
+      ? []
+      : [`${side} fitting reached iterationLimit ${policy.iterationLimit}`]
+  };
+}
+
+function fitMargins(program, policy) {
+  let probeProgram = program;
+  let margin = { ...program.materializationConfigs.canvas.margin };
+  let iterations = 0;
+  const issues = [];
+  for (const side of SIDES) {
+    const result = minimizeSide(probeProgram, margin, side, policy);
+    probeProgram = result.program;
+    margin = result.margin;
+    iterations += result.iterations;
+    issues.push(...result.issues);
+  }
+  return { margin, iterations, issues };
+}
+
+function sameMargin(first, second) {
+  return SIDES.every(side => first[side] === second[side]);
+}
+
+function samePolicy(first, second) {
+  return OPTIONS.every(option => first?.[option] === second[option]);
+}
+
+function layoutSignature(program) {
+  const source = JSON.stringify({
+    graphicSpec: program.graphicSpec,
+    canvas: program.materializationConfigs.canvas,
+    guides: program.materializationConfigs.guides,
+    title: program.materializationConfigs.title
+  });
+  let hash = 0xcbf29ce484222325n;
+  for (let index = 0; index < source.length; index += 1) {
+    hash ^= BigInt(source.charCodeAt(index));
+    hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+
+export const fitCanvas = action(
+  {
+    op: "fitCanvas",
+    description: "Fit Canvas margins around existing layout resources."
+  },
+  function (args = {}) {
+    const policy = normalizeOptions(args);
+    const canvas = findCanvasGraphic(this);
+    if (canvas?.type !== "canvas" ||
+        this.materializationConfigs.canvas?.margin === undefined) {
+      throw new Error("fitCanvas requires an existing Canvas.");
+    }
+    const previous = this.materializationConfigs.fitting;
+    if (samePolicy(previous?.policy, policy) &&
+        previous?.result?.signature === layoutSignature(this)) {
+      return this;
+    }
+    const sourceMargin = this.materializationConfigs.canvas.margin;
+    const fitted = fitMargins(this, policy);
+    let next = sameMargin(sourceMargin, fitted.margin)
+      ? this
+      : this.editCanvas({ margin: fitted.margin });
+    const plot = resolveGraphicBounds(next);
+    if (plot.width < policy.minPlotWidth) {
+      fitted.issues.push(
+        `plot width ${plot.width} is smaller than minPlotWidth ${policy.minPlotWidth}`
+      );
+    }
+    if (plot.height < policy.minPlotHeight) {
+      fitted.issues.push(
+        `plot height ${plot.height} is smaller than minPlotHeight ${policy.minPlotHeight}`
+      );
+    }
+    if (fitted.issues.length > 0 && policy.overflow === "error") {
+      throw new Error(`fitCanvas overflow: ${fitted.issues.join("; ")}.`);
+    }
+    next = next._withMaterializationConfig(["fitting"], {
+      policy,
+      result: {
+        status: fitted.issues.length === 0 ? "fit" : "overflow",
+        margin: fitted.margin,
+        plot: { width: plot.width, height: plot.height },
+        iterations: fitted.iterations,
+        issues: fitted.issues,
+        signature: layoutSignature(next)
+      }
+    });
+    return next;
+  }
+);

package/src/actions/canvas/index.js

@@ -1,8 +1,10 @@
 import { createBasicCanvas, createCanvas, editCanvas } from "./actions.js";
+import { fitCanvas } from "./fitting.js";
 
 export function registerCanvasActions(ProgramClass) {
   ProgramClass.prototype.editCanvas = editCanvas;
   ProgramClass.prototype.createCanvas = createCanvas;
+  ProgramClass.prototype.fitCanvas = fitCanvas;
 }
 
 export function registerBasicCanvasActions(ProgramClass) {

package/src/actions/categoryOrder/index.js

@@ -8,9 +8,13 @@ import {
   applyMaterializationPlan,
   planScaleGuideRematerialization
 } from "../../materialization/dependencies.js";
-import { getMarkMaterializationStep } from "../../materialization/marks/index.js";
+import {
+  getMarkMaterializationStep,
+  getSourceDependentMarkSteps
+} from "../../materialization/marks/index.js";
 import { buildMaterializationPlan } from "../../materialization/planner.js";
 import {
+  CATEGORY_ORDER_CHANNELS,
   normalizeCategoryOrder,
   resolveCategoryOrder
 } from "../../grammar/categoryOrder.js";
@@ -19,8 +23,8 @@ const ORDER_OPTIONS = Object.freeze(["target", "channel", "values", "by", "direc
 const REMOVE_OPTIONS = Object.freeze(["target", "channel"]);
 
 function resolveAssignment(program, args, operation, { activeOnly = false } = {}) {
-  if (!["x", "y"].includes(args.channel)) {
-    throw new Error(`${operation} channel must be x or y.`);
+  if (!CATEGORY_ORDER_CHANNELS.includes(args.channel)) {
+    throw new Error(`${operation} channel must be x, y, or theta.`);
   }
   const requested = args.target === undefined
     ? undefined
@@ -55,14 +59,22 @@ function resolveAssignment(program, args, operation, { activeOnly = false } = {}
 
 function rematerializeAssignment(program, scaleId) {
   const consumers = findScaleConsumers(program, scaleId);
+  const directMarks = consumers.map(consumer =>
+    getMarkMaterializationStep(program, consumer.layer)
+  );
   return applyMaterializationPlan(program, buildMaterializationPlan({
     scales: [{
       op: "rematerializeScale",
       args: { id: scaleId, guides: false, marks: false }
     }],
-    marks: consumers.map(consumer =>
-      getMarkMaterializationStep(program, consumer.layer)
-    ),
+    marks: [
+      ...directMarks,
+      ...directMarks.flatMap(step =>
+        step === undefined
+          ? []
+          : getSourceDependentMarkSteps(program, step.args.id)
+      )
+    ],
     guides: planScaleGuideRematerialization(program, scaleId)
   }));
 }