ggaction 0.0.4 → 0.0.6

package/src/layout/labels.js

@@ -0,0 +1,270 @@
+import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { resolveTextBounds } from "../core/textMetrics.js";
+import {
+  validateNonNegativeFinite,
+  validateOptionObject
+} from "../core/validation.js";
+
+const AXES = new Set(["x", "y", "both"]);
+const BOUNDS = new Set(["plot", "canvas"]);
+const POLICY_OPTIONS = Object.freeze([
+  "axis", "padding", "maxDisplacement", "bounds"
+]);
+
+export const DEFAULT_LABEL_LAYOUT_GEOMETRY = cloneAndFreeze({
+  axis: "both",
+  padding: 3,
+  maxDisplacement: 48,
+  bounds: "plot"
+});
+
+export function normalizeLabelLayoutGeometry(options = {}) {
+  validateOptionObject(options, POLICY_OPTIONS, "label layout");
+  const normalized = {
+    ...DEFAULT_LABEL_LAYOUT_GEOMETRY,
+    ...options
+  };
+  if (!AXES.has(normalized.axis)) {
+    throw new Error(`Unsupported label layout axis "${normalized.axis}".`);
+  }
+  if (!BOUNDS.has(normalized.bounds)) {
+    throw new Error(`Unsupported label layout bounds "${normalized.bounds}".`);
+  }
+  validateNonNegativeFinite(normalized.padding, "Label layout padding");
+  validateNonNegativeFinite(
+    normalized.maxDisplacement,
+    "Label layout maxDisplacement"
+  );
+  return cloneAndFreeze(normalized);
+}
+
+function validateBounds(bounds) {
+  if (
+    !isPlainObject(bounds) ||
+    ![bounds.left, bounds.right, bounds.top, bounds.bottom].every(Number.isFinite) ||
+    bounds.right <= bounds.left ||
+    bounds.bottom <= bounds.top
+  ) {
+    throw new RangeError("Label layout requires ordered finite bounds.");
+  }
+}
+
+function validateItem(item, ids) {
+  if (!isPlainObject(item)) {
+    throw new TypeError("Label layout items must be plain objects.");
+  }
+  if (typeof item.id !== "string" || item.id.length === 0 || ids.has(item.id)) {
+    throw new TypeError("Label layout items require unique non-empty ids.");
+  }
+  if (
+    ![item.x, item.y, item.sourceX, item.sourceY, item.fontSize]
+      .every(Number.isFinite) ||
+    item.fontSize <= 0 ||
+    typeof item.text !== "string" ||
+    item.text.length === 0
+  ) {
+    throw new TypeError(
+      "Label layout items require text, positive fontSize, and finite geometry."
+    );
+  }
+  ids.add(item.id);
+}
+
+function expanded(bounds, padding) {
+  const half = padding / 2;
+  return {
+    left: bounds.left - half,
+    right: bounds.right + half,
+    top: bounds.top - half,
+    bottom: bounds.bottom + half
+  };
+}
+
+function intersectionArea(first, second) {
+  const width = Math.min(first.right, second.right) -
+    Math.max(first.left, second.left);
+  const height = Math.min(first.bottom, second.bottom) -
+    Math.max(first.top, second.top);
+  return width > 0 && height > 0 ? width * height : 0;
+}
+
+function overflow(bounds, boundary) {
+  return Math.max(0, boundary.left - bounds.left) +
+    Math.max(0, bounds.right - boundary.right) +
+    Math.max(0, boundary.top - bounds.top) +
+    Math.max(0, bounds.bottom - boundary.bottom);
+}
+
+export function enumerateLabelOffsets({ axis, padding, maxDisplacement }) {
+  const policy = normalizeLabelLayoutGeometry({ axis, padding, maxDisplacement });
+  const step = Math.max(2, policy.padding);
+  const limit = Math.ceil(policy.maxDisplacement / step);
+  const candidates = [];
+  for (let x = -limit; x <= limit; x += 1) {
+    for (let y = -limit; y <= limit; y += 1) {
+      if (policy.axis === "x" && y !== 0) continue;
+      if (policy.axis === "y" && x !== 0) continue;
+      const offset = { x: x * step, y: y * step };
+      const distanceSquared = offset.x ** 2 + offset.y ** 2;
+      if (Math.sqrt(distanceSquared) > policy.maxDisplacement + 1e-9) continue;
+      candidates.push({ ...offset, distanceSquared });
+    }
+  }
+  candidates.sort((first, second) =>
+    first.distanceSquared - second.distanceSquared ||
+    Math.abs(first.x) - Math.abs(second.x) ||
+    first.y - second.y ||
+    second.x - first.x
+  );
+  return cloneAndFreeze(candidates);
+}
+
+function textBounds(item, offset = { x: 0, y: 0 }) {
+  return resolveTextBounds({
+    x: item.x + offset.x,
+    y: item.y + offset.y,
+    text: item.text,
+    fontSize: item.fontSize,
+    textAlign: item.textAlign,
+    textBaseline: item.textBaseline,
+    rotation: item.rotation
+  });
+}
+
+function candidateScore(bounds, boundary, placed, candidate, order) {
+  return {
+    outside: overflow(bounds, boundary),
+    overlap: placed.reduce(
+      (area, prior) => area + intersectionArea(bounds, prior),
+      0
+    ),
+    distanceSquared: candidate.distanceSquared,
+    order
+  };
+}
+
+function compareScore(first, second) {
+  return Number(first.outside > 0) - Number(second.outside > 0) ||
+    first.outside - second.outside ||
+    first.overlap - second.overlap ||
+    first.distanceSquared - second.distanceSquared ||
+    first.order - second.order;
+}
+
+function overlapPairs(items) {
+  const pairs = [];
+  for (let first = 0; first < items.length; first += 1) {
+    for (let second = first + 1; second < items.length; second += 1) {
+      if (
+        intersectionArea(
+          items[first].collisionBounds,
+          items[second].collisionBounds
+        ) > 0
+      ) {
+        pairs.push([items[first].id, items[second].id]);
+      }
+    }
+  }
+  return pairs;
+}
+
+export function resolveLabelLayout({ items, bounds, ...options } = {}) {
+  if (!Array.isArray(items)) {
+    throw new TypeError("Label layout requires an item array.");
+  }
+  validateBounds(bounds);
+  const policy = normalizeLabelLayoutGeometry(options);
+  const ids = new Set();
+  for (const item of items) validateItem(item, ids);
+  const candidates = enumerateLabelOffsets(policy);
+  const base = items.map(item => ({
+    id: item.id,
+    collisionBounds: expanded(textBounds(item), policy.padding)
+  }));
+  const placed = [];
+  const resolved = [];
+  for (const item of items) {
+    let best;
+    for (const [order, candidate] of candidates.entries()) {
+      const boundsAtCandidate = textBounds(item, candidate);
+      const collisionBounds = expanded(boundsAtCandidate, policy.padding);
+      const score = candidateScore(
+        collisionBounds,
+        bounds,
+        placed,
+        candidate,
+        order
+      );
+      if (best === undefined || compareScore(score, best.score) < 0) {
+        best = { candidate, bounds: boundsAtCandidate, collisionBounds, score };
+      }
+      if (score.outside === 0 && score.overlap === 0) break;
+    }
+    const resolvedItem = {
+      ...item,
+      baseX: item.x,
+      baseY: item.y,
+      x: item.x + best.candidate.x,
+      y: item.y + best.candidate.y,
+      dx: best.candidate.x,
+      dy: best.candidate.y,
+      distance: Math.sqrt(best.candidate.distanceSquared),
+      bounds: best.bounds,
+      collisionBounds: best.collisionBounds
+    };
+    placed.push(resolvedItem.collisionBounds);
+    resolved.push(resolvedItem);
+  }
+  const beforePairs = overlapPairs(base);
+  const afterPairs = overlapPairs(resolved);
+  const outside = resolved
+    .filter(item => overflow(item.collisionBounds, bounds) > 0)
+    .map(item => item.id);
+  const warnings = [];
+  if (afterPairs.length > 0) warnings.push({ code: "overlap", pairs: afterPairs });
+  if (outside.length > 0) warnings.push({ code: "bounds", items: outside });
+  return cloneAndFreeze({
+    items: resolved,
+    overlapBefore: beforePairs.length,
+    overlapAfter: afterPairs.length,
+    warnings
+  });
+}
+
+function contains(bounds, point) {
+  return point.x >= bounds.left && point.x <= bounds.right &&
+    point.y >= bounds.top && point.y <= bounds.bottom;
+}
+
+export function resolveLabelLeader(item) {
+  if (!isPlainObject(item) || ![item.dx, item.dy].every(Number.isFinite)) {
+    throw new TypeError("Label leader requires a resolved label item.");
+  }
+  if (item.dx === 0 && item.dy === 0) return undefined;
+  const source = { x: item.sourceX, y: item.sourceY };
+  if (contains(item.bounds, source)) return undefined;
+  const center = {
+    x: (item.bounds.left + item.bounds.right) / 2,
+    y: (item.bounds.top + item.bounds.bottom) / 2
+  };
+  const dx = center.x - source.x;
+  const dy = center.y - source.y;
+  const enterX = dx > 0
+    ? (item.bounds.left - source.x) / dx
+    : dx < 0
+      ? (item.bounds.right - source.x) / dx
+      : 0;
+  const enterY = dy > 0
+    ? (item.bounds.top - source.y) / dy
+    : dy < 0
+      ? (item.bounds.bottom - source.y) / dy
+      : 0;
+  const ratio = Math.max(0, Math.min(1, Math.max(enterX, enterY)));
+  return cloneAndFreeze({
+    id: item.id,
+    x1: source.x,
+    y1: source.y,
+    x2: source.x + dx * ratio,
+    y2: source.y + dy * ratio
+  });
+}

package/src/layout/text.js

@@ -1,6 +1,9 @@
 import { measureTextWidth } from "../core/textMetrics.js";
 
-export { measureTextWidth } from "../core/textMetrics.js";
+export {
+  measureTextWidth,
+  resolveTextBounds
+} from "../core/textMetrics.js";
 
 function wrapCodePoints(text, maxWidth, style) {
   const lines = [];

package/src/layout/title.js

@@ -1,4 +1,4 @@
-import { measureTextWidth, wrapText } from "./text.js";
+import { measureTextWidth, resolveTextBounds, wrapText } from "./text.js";
 
 function lineCenters(lines, style, lineHeight, start) {
   return lines.map((_, index) => start + style.fontSize / 2 + index * lineHeight);
@@ -62,25 +62,15 @@ export function alignedTextAnchor(start, length, align) {
 }
 
 function axisAlignedTextBounds({ x, y, text, style, align, rotation }) {
-  const width = measureTextWidth(text, style);
-  const left = align === "left" ? 0 : align === "center" ? -width / 2 : -width;
-  const right = left + width;
-  const top = -style.fontSize / 2;
-  const bottom = style.fontSize / 2;
-  const cosine = Math.cos(rotation);
-  const sine = Math.sin(rotation);
-  const corners = [
-    [left, top], [right, top], [right, bottom], [left, bottom]
-  ].map(([localX, localY]) => ({
-    x: x + localX * cosine - localY * sine,
-    y: y + localX * sine + localY * cosine
-  }));
-  return {
-    left: Math.min(...corners.map(point => point.x)),
-    right: Math.max(...corners.map(point => point.x)),
-    top: Math.min(...corners.map(point => point.y)),
-    bottom: Math.max(...corners.map(point => point.y))
-  };
+  return resolveTextBounds({
+    x,
+    y,
+    text,
+    ...style,
+    textAlign: align,
+    textBaseline: "middle",
+    rotation
+  });
 }
 
 function unionBounds(bounds) {

package/src/materialization/dataProvenance.js

@@ -1,4 +1,56 @@
-import { findDataset } from "../selectors/datasets.js";
+import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { validateUserId } from "../core/identifiers.js";
+import { findTransformPolicy } from "../grammar/transforms.js";
+import { findDataset, hasDataset } from "../selectors/datasets.js";
+import { requireLayer } from "../selectors/layers.js";
+
+function validateRevisionRole(value) {
+  if (typeof value !== "string" || !/^[A-Za-z][A-Za-z0-9]*$/.test(value)) {
+    throw new TypeError(
+      "Derived dataset revision role must be an alphanumeric identifier."
+    );
+  }
+  return value;
+}
+
+function nextRevisionId(program, owner, role) {
+  let revision = 1;
+  const prefix = `${owner}${role}Revision`;
+  while (hasDataset(program, `${prefix}${revision}`)) revision += 1;
+  return `${prefix}${revision}`;
+}
+
+export function planDerivedDataRevision(program, options = {}) {
+  if (!isPlainObject(options)) {
+    throw new TypeError("Derived dataset revision options must be a plain object.");
+  }
+  const owner = validateUserId(options.owner, "Derived dataset revision owner");
+  const role = validateRevisionRole(options.role);
+  const previous = options.previous === undefined
+    ? undefined
+    : validateUserId(options.previous, "Previous derived dataset id");
+  if (previous !== undefined && !hasDataset(program, previous)) {
+    throw new Error(`Unknown previous derived dataset "${previous}".`);
+  }
+  if (!Array.isArray(options.consumers)) {
+    throw new TypeError("Derived dataset revision consumers must be an array.");
+  }
+  const consumers = options.consumers.map(id => {
+    const validated = validateUserId(id, "Derived dataset consumer id");
+    requireLayer(program, validated);
+    return validated;
+  });
+  if (new Set(consumers).size !== consumers.length) {
+    throw new Error("Derived dataset revision consumers must be unique.");
+  }
+  const id = nextRevisionId(program, owner, role);
+  return cloneAndFreeze({
+    id,
+    ...(previous === undefined ? {} : { previous }),
+    rebinds: consumers.map(consumer => ({ id: consumer, data: id })),
+    ...(previous === undefined ? {} : { release: { id: previous } })
+  });
+}
 
 export function findUpstreamTransform(program, dataset, type) {
   const visited = new Set();
@@ -8,7 +60,9 @@ export function findUpstreamTransform(program, dataset, type) {
     if (current.transform?.length !== 1) return undefined;
     const transform = current.transform[0];
     if (transform.type === type) return transform;
-    if (transform.type !== "markFilter") return undefined;
+    if (findTransformPolicy(transform.type)?.provenanceTransparent !== true) {
+      return undefined;
+    }
     current = findDataset(program, current.source);
   }
   return undefined;

package/src/materialization/dependencies.js

@@ -14,12 +14,13 @@ import {
   needsCanvasScaleRematerialization,
   planScaleGuideRematerialization
 } from "./scaleGuideDependencies.js";
+import { planLayoutRematerialization } from "./layout.js";
 
-function hasTitle(program) {
-  return (
-    program.semanticSpec.title.text !== undefined &&
-    program.titleConfig !== undefined
-  );
+function layerScaleIds(layer) {
+  return [
+    ...Object.values(layer.encoding ?? {}).map(encoding => encoding?.scale),
+    ...(layer.encoding?.parallel?.dimensions ?? []).map(dimension => dimension.scale)
+  ].filter(scale => scale !== undefined);
 }
 
 export function planCanvasRematerialization(program) {
@@ -37,9 +38,7 @@ export function planCanvasRematerialization(program) {
     if (needsCanvasScaleRematerialization(program, scale)) {
       const deferredConsumers = program.semanticSpec.layers.filter(layer =>
         canDeferScaleConsumerApplication(layer) &&
-        Object.values(layer.encoding ?? {}).some(
-          encoding => encoding?.scale === scale.id
-        )
+        layerScaleIds(layer).includes(scale.id)
       );
       const canDeferMarks = deferredConsumers.length === 0 ||
         deferredConsumers.every(layer => deferredMarkIds.has(layer.id));
@@ -61,17 +60,13 @@ export function planCanvasRematerialization(program) {
   if (hasMaterializedLegend(program)) {
     guides.push({ op: "rematerializeLegend" });
   }
-  const layout = hasTitle(program) ? [{ op: "rematerializeTitle" }] : [];
+  const layout = planLayoutRematerialization(program);
   return buildMaterializationPlan({ scales, marks, guides, layout });
 }
 
 export function planLayerDataRematerialization(program, id) {
   const layer = requireLayer(program, id);
-  const scaleIds = [...new Set(
-    Object.values(layer.encoding ?? {})
-      .map(encoding => encoding?.scale)
-      .filter(scale => scale !== undefined)
-  )];
+  const scaleIds = [...new Set(layerScaleIds(layer))];
   const markStep = getMarkMaterializationStep(program, layer);
   const scales = scaleIds.map(scale => ({
       op: "rematerializeScale",

package/src/materialization/guides/resources.js

@@ -5,27 +5,66 @@ const CATEGORICAL_COMPONENTS = Object.freeze([
   "Labels", "Title", "Background"
 ]);
 
-const LEGEND_GRAPHICS = Object.freeze({
-  series: Object.freeze(CATEGORICAL_COMPONENTS.map(
-    component => `seriesLegend${component}`
-  )),
-  color: Object.freeze(CATEGORICAL_COMPONENTS.map(
-    component => `colorLegend${component}`
-  )),
-  size: Object.freeze([
-    "sizeLegendSymbols", "sizeLegendLabels", "sizeLegendTitle"
-  ]),
-  gradient: Object.freeze([
-    "colorGradientBackground", "colorGradientStrips", "colorGradientTicks",
-    "colorGradientLabels", "colorGradientTitle"
-  ]),
-  interval: Object.freeze([
-    "colorLegendSymbols", "colorLegendLabels", "colorLegendTitle"
-  ]),
-  opacity: Object.freeze([
-    "opacityLegendBackground", "opacityLegendSymbols", "opacityLegendLabels",
-    "opacityLegendTitle"
-  ])
+const LEGEND_RESOURCE_POLICIES = Object.freeze({
+  series: Object.freeze({
+    semanticKind: "series",
+    family: "categorical",
+    rematerializeOp: undefined,
+    graphicIds: Object.freeze(CATEGORICAL_COMPONENTS.map(
+      component => `seriesLegend${component}`
+    ))
+  }),
+  color: Object.freeze({
+    semanticKind: "color",
+    family: "categorical",
+    rematerializeOp: undefined,
+    graphicIds: Object.freeze(CATEGORICAL_COMPONENTS.map(
+      component => `colorLegend${component}`
+    ))
+  }),
+  size: Object.freeze({
+    semanticKind: "size",
+    family: "size",
+    rematerializeOp: "rematerializeSizeLegend",
+    graphicIds: Object.freeze([
+      "sizeLegendSymbols", "sizeLegendLabels", "sizeLegendTitle"
+    ])
+  }),
+  gradient: Object.freeze({
+    semanticKind: "color",
+    family: "continuous",
+    rematerializeOp: "rematerializeGradientLegend",
+    graphicIds: Object.freeze([
+      "colorGradientBackground", "colorGradientStrips", "colorGradientTicks",
+      "colorGradientLabels", "colorGradientTitle"
+    ])
+  }),
+  interval: Object.freeze({
+    semanticKind: "color",
+    family: "interval",
+    rematerializeOp: "rematerializeIntervalLegend",
+    graphicIds: Object.freeze([
+      "colorLegendSymbols", "colorLegendLabels", "colorLegendTitle"
+    ])
+  }),
+  opacity: Object.freeze({
+    semanticKind: "opacity",
+    family: "continuous",
+    rematerializeOp: "rematerializeOpacityLegend",
+    graphicIds: Object.freeze([
+      "opacityLegendBackground", "opacityLegendSymbols", "opacityLegendLabels",
+      "opacityLegendTitle"
+    ])
+  }),
+  strokeWidth: Object.freeze({
+    semanticKind: "strokeWidth",
+    family: "strokeWidth",
+    rematerializeOp: "rematerializeStrokeWidthLegend",
+    graphicIds: Object.freeze([
+      "strokeWidthLegendSymbols", "strokeWidthLegendLabels",
+      "strokeWidthLegendTitle"
+    ])
+  })
 });
 
 export function axisGraphicIds(channel) {
@@ -34,11 +73,22 @@ export function axisGraphicIds(channel) {
 }
 
 export function legendGraphicIds(kind) {
-  const ids = LEGEND_GRAPHICS[kind];
-  if (ids === undefined) {
+  return legendResourcePolicy(kind).graphicIds;
+}
+
+export function legendResourcePolicy(kind) {
+  const policy = LEGEND_RESOURCE_POLICIES[kind];
+  if (policy === undefined) {
     throw new Error(`Unknown legend graphic kind "${kind}".`);
   }
-  return ids;
+  return policy;
+}
+
+export function legendResourcePolicies() {
+  return Object.entries(LEGEND_RESOURCE_POLICIES).map(([kind, policy]) => ({
+    kind,
+    ...policy
+  }));
 }
 
 export function allLegendGraphicIds(kinds) {

package/src/materialization/horizon.js

@@ -0,0 +1,29 @@
+import { getMarkMaterializationStep } from "./marks/index.js";
+import { buildMaterializationPlan } from "./planner.js";
+import { requireLayer } from "../selectors/layers.js";
+
+export function planHorizonRematerialization(program, target) {
+  const layer = requireLayer(
+    program,
+    target,
+    `Unknown Horizon materialization target "${target}"`
+  );
+  const scaleIds = new Set([
+    layer.encoding?.x?.scale,
+    layer.encoding?.y?.scale,
+    layer.encoding?.color?.scale
+  ].filter(Boolean));
+  const ordered = [
+    layer,
+    ...program.semanticSpec.layers.filter(candidate => candidate.id !== target)
+  ];
+  const marks = ordered.flatMap(candidate => {
+    const consumesScale = Object.values(candidate.encoding ?? {}).some(
+      encoding => scaleIds.has(encoding?.scale)
+    );
+    if (!consumesScale) return [];
+    const step = getMarkMaterializationStep(program, candidate);
+    return step === undefined ? [] : [step];
+  });
+  return buildMaterializationPlan({ marks });
+}

package/src/materialization/layout.js

@@ -0,0 +1,15 @@
+const LAYOUT_CONSUMER_POLICIES = Object.freeze([
+  Object.freeze({
+    applies(program) {
+      return program.semanticSpec.title.text !== undefined &&
+        program.titleConfig !== undefined;
+    },
+    step: Object.freeze({ op: "rematerializeTitle" })
+  })
+]);
+
+export function planLayoutRematerialization(program) {
+  return LAYOUT_CONSUMER_POLICIES.flatMap(policy =>
+    policy.applies(program) ? [policy.step] : []
+  );
+}

package/src/materialization/marks/capabilities.js

@@ -1,5 +1,6 @@
 import { findDataset } from "../../selectors/datasets.js";
 import { findLayer } from "../../selectors/layers.js";
+import { findCoordinate } from "../../selectors/coordinates.js";
 import { isAggregate } from "../../grammar/aggregate.js";
 import {
   BAR_GRAINS,
@@ -32,6 +33,14 @@ export function canMaterializePoint(_program, layer) {
 }
 
 export function canMaterializeLine(program, layer) {
+  const parallel = layer.encoding?.parallel;
+  if (parallel !== undefined) {
+    const coordinate = findCoordinate(program, layer.coordinate);
+    return layer.mark?.type === "line" &&
+      coordinate?.type === "parallel" &&
+      parallel.dimensions?.length >= 2 &&
+      parallel.dimensions.every(dimension => dimension.scale !== undefined);
+  }
   const dataset = findDataset(program, layer.data);
   const interval = dataset?.transform?.some(item => item.type === "interval");
   if (hasPolarPositionScales(layer)) {
@@ -62,6 +71,7 @@ export function canMaterializeArea(program, layer) {
   }
   const dataset = findDataset(program, layer.data);
   const densityTransform = findUpstreamTransform(program, dataset, "density");
+  if (isIntentionallyEmptyArea(program, layer)) return false;
   const completeDensity =
     densityTransform !== undefined &&
     (densityTransform.groupBy === undefined ||
@@ -73,6 +83,16 @@ export function canMaterializeArea(program, layer) {
   );
 }
 
+export function isIntentionallyEmptyArea(program, layer) {
+  if (
+    layer.mark?.type !== "area" ||
+    !Array.isArray(program.semanticSpec?.datasets)
+  ) return false;
+  const dataset = findDataset(program, layer.data);
+  return dataset?.values?.length === 0 &&
+    findUpstreamTransform(program, dataset, "horizon") !== undefined;
+}
+
 export function canMaterializeArc(_program, layer) {
   if (
     layer.mark?.type !== "arc" ||
@@ -81,7 +101,7 @@ export function canMaterializeArc(_program, layer) {
   ) {
     return false;
   }
-  if (layer.encoding.theta.aggregate === "count") {
+  if (["count", "sum"].includes(layer.encoding.theta.aggregate)) {
     return layer.encoding?.radius === undefined;
   }
   return (

package/src/materialization/marks/index.js

@@ -96,6 +96,9 @@ export function getEncodingMaterializationStages(program, layer, channel, scale)
       )
     : [layer];
   const marks = candidates.flatMap(candidate => {
+    if (policy.encoding?.skipRematerialization?.(program, candidate) === true) {
+      return [];
+    }
     const step = policy.encoding?.completeOnly === true
       ? getMarkMaterializationStep(program, candidate)
       : getMarkRematerializationStep(candidate);