ggaction 0.0.17 → 0.0.19

package/src/materialization/scales/resolve.js

@@ -160,7 +160,7 @@ function resolveContinuousScale({
 }) {
   return {
     type: isSequentialColor
-      ? "sequential"
+      ? scale.type
       : isOrdinalAppearance
         ? validateOrdinalScaleType(scale.type)
         : scale.type === "time"
@@ -200,6 +200,8 @@ function resolveContinuousScale({
             }
           : {}),
     ...(isSequentialColor ? { interpolate: scale.interpolate ?? "rgb" } : {}),
+    ...(scale.whitePoint === undefined ? {} : {whitePoint: scale.whitePoint}),
+    ...(scale.gamma === undefined ? {} : {gamma: scale.gamma}),
     ...(Object.hasOwn(scale, "unknown") ? { unknown: scale.unknown } : {})
   };
 }
@@ -377,7 +379,7 @@ export function resolveScaleMaterialization(options) {
   validateMeasuredRadiusConsumers({ scale, domain, range, consumers, markConfigs, thetaScales });
   if (channel === "shape" && domain.length > range.length) {
     throw new Error(
-      `Shape scale "${id}" requires at least one distinct shape per domain value.`
+      `Shape scale "${id}" requires at least one shape entry per domain value.`
     );
   }
 
@@ -440,7 +442,9 @@ export function resolveScaleMaterialization(options) {
     const temporalBarBand = resolveTemporalBarBand(
       valuesByConsumer,
       domain,
-      range
+      range,
+      markConfigs,
+      Array.isArray(scale.range)
     );
     if (temporalBarBand !== undefined) {
       resolvedScale = {

package/src/materialization/selection/items/arc.js

@@ -16,7 +16,7 @@ export function resolveArcItems(program, layer, dataset) {
     thetaScale,
     ...(radiusScale === undefined ? {} : { radiusScale }),
     frame,
-    innerRadiusRatio: program.markConfigs[layer.id]?.innerRadius ?? 0
+    innerRadius: program.markConfigs[layer.id]?.innerRadius ?? 0
   });
   const graphic = program.graphicSpec.objects[layer.id];
   const stroke = layer.encoding?.stroke;

package/src/materialization/selection/items/bar.js

@@ -1,3 +1,4 @@
+import { hasRectRadius } from "../../../grammar/roundedRect.js";
 import { deriveSeriesBarCells } from "../../../grammar/bars/aggregate.js";
 import { readSeriesIdentity } from "../../../grammar/pathSeries.js";
 import {
@@ -128,9 +129,12 @@ function histogramDefinitions(program, layer, dataset) {
 }
 
 function rangedDefinitions(layer, dataset) {
+  const measure = resolveBarGrain(layer) === BAR_GRAINS.centered ? resolveBarChannels(layer).measure : undefined;
   return dataset.values.map(row => ({
     fields: ownFields(row),
-    channels: channelMapFromRow(row, layer),
+    channels: { ...channelMapFromRow(row, layer),
+      ...(measure !== undefined && layer.encoding[`${measure}2`] === undefined
+        ? { [measure]: 0, [`${measure}2`]: row[layer.encoding[measure].field] } : {}) },
     members: [row]
   }));
 }
@@ -205,16 +209,13 @@ export function resolveBarItems(program, layer, dataset, selectionGrain) {
     ? histogramDefinitions(program, layer, dataset)
     : grain === BAR_GRAINS.aggregate
       ? aggregateCellDefinitions(program, layer, dataset)
-      : grain === BAR_GRAINS.ranged
+      : [BAR_GRAINS.ranged, BAR_GRAINS.centered].includes(grain)
         ? rangedDefinitions(layer, dataset)
         : undefined;
   if (definitions === undefined) {
     throw new Error(`Bar mark "${layer.id}" is incomplete for selection.`);
   }
-  const graphicTypes = Object.hasOwn(
-    program.markConfigs[layer.id]?.barAppearance ?? {},
-    "cornerRadius"
-  ) ? ["rect", "path"] : "rect";
+  const graphicTypes = hasRectRadius(program.markConfigs[layer.id]?.barAppearance) ? ["rect", "path"] : "rect";
   if (selectionGrain === "stack") {
     return finalizeItems(
       program,

package/src/materialization/selection/items/path.js

@@ -59,15 +59,16 @@ export function resolveLineItems(program, layer, dataset) {
   const derived = deriveLineSeries(
     dataset.values,
     layer,
-    x?.bin === undefined
-      ? undefined
-      : {
+    {
+      xDomain: program.resolvedScales[x?.scale]?.domain,
+      ...(x?.bin === undefined ? {} : {
           xBinBoundaries: resolveLineBins(
             dataset.values,
             layer,
             requireSemanticScale(program, x.scale)
           ).boundaries
-        }
+        })
+    }
   );
   return finalizeItems(
     program,
@@ -82,8 +83,8 @@ export function resolveAreaItems(program, layer, dataset) {
   const transform = findUpstreamTransform(program, dataset, "density");
   const derived = transform === undefined
     ? layer.encoding?.y?.stack === "center"
-      ? deriveCenteredAreaSeries(dataset.values, layer)
-      : deriveAreaSeries(dataset.values, layer)
+      ? deriveCenteredAreaSeries(dataset.values, layer, { xDomain: program.resolvedScales[layer.encoding.x?.scale]?.domain, yDomain: program.resolvedScales[layer.encoding.y?.scale]?.domain })
+      : deriveAreaSeries(dataset.values, layer, { xDomain: program.resolvedScales[layer.encoding.x?.scale]?.domain, yDomain: program.resolvedScales[layer.encoding.y?.scale]?.domain })
     : deriveDensityAreaSeries(dataset.values, layer, transform);
   return finalizeItems(
     program,

package/src/materialization/selection/items/rect.js

@@ -1,5 +1,5 @@
 import { rectUsesFields } from "../../../grammar/rects.js";
-import { readRectItemGeometry } from "../../../grammar/roundedRect.js";
+import { hasRectRadius, readRectItemGeometry } from "../../../grammar/roundedRect.js";
 import { resolveRectRows } from "../../rect.js";
 import {
   channelMapFromRow,
@@ -40,7 +40,7 @@ function resolveGradientPlotItems(program, layer, dataset) {
 
 export function resolveRectItems(program, layer, dataset) {
   const graphic = program.graphicSpec.objects[layer.id];
-  const rounded = Object.hasOwn(program.markConfigs[layer.id] ?? {}, "cornerRadius");
+  const rounded = hasRectRadius(program.markConfigs[layer.id]);
   const compatibleCollection = rounded && graphic?.type === "collection" &&
     graphic.items?.every(item => ["rect", "path"].includes(item.type));
   if (

package/src/materialization/text.js

@@ -5,7 +5,7 @@ import {
   resolveMarkLabelPlacement
 } from "../layout/labels.js";
 import { resolveMarkLabelValues } from "../grammar/markLabels.js";
-import { formatTextValue } from "../grammar/text.js";
+import { formatTextValue, resolveTextLines } from "../grammar/text.js";
 import { normalizePositionDatum } from "../grammar/positionDatum.js";
 import { mapOrdinalPositionValues } from "../grammar/scales/index.js";
 import { findDataset } from "../selectors/datasets.js";
@@ -274,12 +274,14 @@ function concreteTextItem(config, position, text, { offsets = true } = {}) {
   if (text === undefined || !Number.isFinite(x) || !Number.isFinite(y)) {
     return undefined;
   }
+  const lines = resolveTextLines(text, config);
   return {
     type: "text",
     properties: {
       x: x + (offsets ? config.dx : 0),
       y: y + (offsets ? config.dy : 0),
       text,
+      ...(lines === undefined ? {} : { lines }),
       fill: config.fill,
       opacity: config.opacity,
       fontSize: config.fontSize,
@@ -310,6 +312,11 @@ function relativeLuminance(color) {
 }
 
 function sourceTextConfig(config, source, item) {
+  if (config.inheritColor && config.fillExplicit !== true) {
+    const fill = item.properties[config.inheritColor];
+    if (typeof fill !== "string") throw new Error(`Source mark "${source.id}" has no resolved ${config.inheritColor} color.`);
+    return { ...config, fill };
+  }
   if (
     !["arc", "rect"].includes(source.mark.type) ||
     config.fillExplicit === true
@@ -383,6 +390,7 @@ function resolveSourceTextItems(program, layer, config) {
       geometry: sourcePlacementGeometry(program, source, item),
       text: {
         text,
+        lines: resolveTextLines(text, resolvedConfig),
         fontSize: resolvedConfig.fontSize,
         fontFamily: resolvedConfig.fontFamily,
         fontWeight: resolvedConfig.fontWeight,
@@ -396,7 +404,7 @@ function resolveSourceTextItems(program, layer, config) {
     if (!resolved.visible) return [];
     if (
       resolved.anchor.startsWith("outside") &&
-      config.fillExplicit !== true
+      config.fillExplicit !== true && !config.inheritColor
     ) {
       resolvedConfig = config;
     }
@@ -420,7 +428,7 @@ function resolveRowTextItems(program, layer, config) {
     throw new Error(`Text mark "${layer.id}" requires an existing dataset.`);
   }
   const dataset = applyItemMissingPolicy(layer, sourceDataset);
-  const encodings = [layer.encoding?.x, layer.encoding?.y, layer.encoding?.text];
+  const encodings = [layer.encoding?.x, layer.encoding?.y, layer.encoding?.text, layer.encoding?.color];
   const length = encodings.some(encoding => encoding !== undefined && Object.hasOwn(encoding, "field"))
     ? dataset.values.length
     : 1;
@@ -454,9 +462,10 @@ function resolveRowTextItems(program, layer, config) {
   const rows = length === 1 && dataset.values.length === 0
     ? [undefined]
     : dataset.values.slice(0, length);
+  const fills = resolveRowEncodingValues(program, layer, dataset, "color");
   return rows.flatMap((row, index) => {
     const concrete = concreteItem(
-      config,
+      fills === undefined ? config : { ...config, fill: fills[index] },
       { x: x[index], y: y[index] },
       contentValue(layer.encoding.text, row),
       layer.encoding.text.format

package/src/materialization/textLines.js

@@ -0,0 +1,15 @@
+import { freezeOwned } from "../core/immutable.js";
+
+// Reconcile optional derived line geometry without recreating its text graphic.
+// The owning wrapped domain materializer records the transition.
+export function materializeTextLines(program, id, lines) {
+  if (lines !== undefined) return program.editGraphics({ target: id, property: "lines", value: lines });
+  const graphic = program.graphicSpec.objects[id];
+  if (!Object.hasOwn(graphic.properties, "lines")) return program;
+  const { lines: _lines, ...properties } = graphic.properties;
+  return program._clone({ graphicSpec: freezeOwned({ ...program.graphicSpec,
+    objects: freezeOwned({ ...program.graphicSpec.objects,
+      [id]: freezeOwned({ ...graphic, properties: freezeOwned(properties) })
+    })
+  }) });
+}

package/src/materialization/typography.js

@@ -1,3 +1,5 @@
+import { cartesianAxisOwners, axisTargetArgs } from "../selectors/axes.js";
+import { axisGraphicIds } from "./guides/resources.js";
 import { applyMaterializationPlan, buildMaterializationPlan } from "./planner.js";
 import { withGuideLayoutTransaction } from "./guides/layout.js";
 
@@ -13,11 +15,17 @@ export function rematerializeTypography(program) {
     .map(layer => ({ op: "rematerializeTextMark", args: { id: layer.id } }));
   const guides = [];
   for (const [id, op] of [
-    ["xAxisLabels", "editXAxisLabels"], ["yAxisLabels", "editYAxisLabels"],
-    ["xAxisTitle", "editXAxisTitle"], ["yAxisTitle", "editYAxisTitle"],
     ["thetaAxisLabels", "editThetaAxisLabels"], ["radialAxisLabels", "editRadialAxisLabels"],
     ["thetaAxisTitle", "editThetaAxisTitle"], ["radialAxisTitle", "editRadialAxisTitle"]
   ]) if (exists(id, op)) guides.push({ op });
+  for (const owner of cartesianAxisOwners(program)) {
+    for (const [index, component] of [[2, "Labels"], [3, "Title"]]) {
+      const op = `edit${owner.channel.toUpperCase()}Axis${component}`;
+      if (exists(axisGraphicIds(owner.channel, owner.id)[index], op)) {
+        guides.push({ op, ...(owner.named ? { args: axisTargetArgs(owner.id, owner.channel) } : {}) });
+      }
+    }
+  }
   const parallel = program.guideConfigs.axis?.parallel?.axes;
   if (parallel !== undefined && typeof program.rematerializeParallelAxes === "function") {
     guides.push({ op: "rematerializeParallelAxes", args: { target: parallel.target } });

package/src/persistence/codec.js

@@ -5,7 +5,7 @@ export function invalidSnapshot(message, optionPath) {
   return annotateError(new TypeError(message), { code: "unsupported-format", optionPath });
 }
 
-export function encodeValue(value, path = "payload", ancestors = new WeakSet()) {
+export function encodeValue(value, path = "payload", ancestors = new WeakSet(), shared) {
   if (value === null || typeof value === "string" || typeof value === "boolean") return value;
   if (value === undefined) return ["undefined"];
   if (typeof value === "bigint") return ["bigint", value.toString()];
@@ -17,6 +17,7 @@ export function encodeValue(value, path = "payload", ancestors = new WeakSet())
   if (ancestors.has(value)) throw invalidSnapshot(`Cannot serialize a cycle at ${path}.`, path);
   if (!Array.isArray(value) && !isPlainObject(value)) throw invalidSnapshot(`Cannot serialize a class instance at ${path}.`, path);
   if (Object.getOwnPropertySymbols(value).length) throw invalidSnapshot(`Cannot serialize symbol keys at ${path}.`, path);
+  if (shared?.seen.has(value)) return shared.seen.get(value);
   const keys = Object.getOwnPropertyNames(value);
   if (Array.isArray(value) ? keys.some(key => key !== "length" && !(/^(0|[1-9]\d*)$/.test(key) && Number(key) < value.length)) :
       keys.some(key => !Object.getOwnPropertyDescriptor(value, key).enumerable)) {
@@ -25,18 +26,48 @@ export function encodeValue(value, path = "payload", ancestors = new WeakSet())
   ancestors.add(value);
   const result = Array.isArray(value)
     ? ["array", Array.from({ length: value.length }, (_, index) => Object.hasOwn(value, index)
-        ? encodeValue(value[index], `${path}[${index}]`, ancestors) : ["hole"])]
-    : ["object", Object.entries(value).map(([key, child]) => [key, encodeValue(child, `${path}.${key}`, ancestors)])];
+        ? encodeValue(value[index], `${path}[${index}]`, ancestors, shared) : ["hole"])]
+    : ["object", Object.entries(value).map(([key, child]) => [key, encodeValue(child, `${path}.${key}`, ancestors, shared)])];
   ancestors.delete(value);
+  if (shared !== undefined && Array.isArray(value) && value.length >= 32) {
+    const key = JSON.stringify(result);
+    let index = shared.keys.get(key);
+    if (index === undefined) {
+      index = shared.arrays.length;
+      shared.keys.set(key, index);
+      shared.arrays.push(result);
+    }
+    const reference = ["reference", index];
+    shared.seen.set(value, reference);
+    return reference;
+  }
   return result;
 }
 
-export function decodeValue(value, path = "payload") {
+export function encodeSharedValue(value) {
+  const shared = { arrays: [], keys: new Map(), seen: new WeakMap() };
+  const root = encodeValue(value, "payload", new WeakSet(), shared);
+  return ["shared", shared.arrays, root];
+}
+
+export function decodeValue(value, path = "payload", references) {
   if (value === null || typeof value === "string" || typeof value === "boolean") return value;
   if (typeof value === "number" && Number.isFinite(value) && !Object.is(value, -0)) return value;
   const invalid = () => { throw invalidSnapshot(`Invalid encoded value at ${path}.`, path); };
   if (!Array.isArray(value)) return invalid();
   const [tag, payload] = value;
+  if (tag === "shared" && references === undefined && value.length === 3 && Array.isArray(payload)) {
+    const arrays = [];
+    for (const [index, encoded] of payload.entries()) {
+      if (!Array.isArray(encoded) || encoded[0] !== "array") return invalid();
+      arrays.push(decodeValue(encoded, `${path}.arrays[${index}]`, arrays));
+    }
+    return decodeValue(value[2], path, arrays);
+  }
+  if (tag === "reference" && references !== undefined && value.length === 2 &&
+      Number.isInteger(payload) && payload >= 0 && payload < references.length) {
+    return references[payload];
+  }
   if (tag === "undefined" && value.length === 1) return undefined;
   if (value.length !== 2) return invalid();
   if (tag === "bigint" && typeof payload === "string" && /^(?:0|-?[1-9]\d*)$/.test(payload)) return BigInt(payload);
@@ -47,7 +78,7 @@ export function decodeValue(value, path = "payload") {
     const result = new Array(payload.length);
     payload.forEach((child, index) => {
       if (Array.isArray(child) && child.length === 1 && child[0] === "hole") return;
-      result[index] = decodeValue(child, `${path}[${index}]`);
+      result[index] = decodeValue(child, `${path}[${index}]`, references ?? []);
     });
     return result;
   }
@@ -56,7 +87,7 @@ export function decodeValue(value, path = "payload") {
     for (const entry of payload) {
       if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string" || Object.hasOwn(result, entry[0])) return invalid();
       Object.defineProperty(result, entry[0], {
-        value: decodeValue(entry[1], `${path}.${entry[0]}`), enumerable: true, writable: true, configurable: true
+        value: decodeValue(entry[1], `${path}.${entry[0]}`, references ?? []), enumerable: true, writable: true, configurable: true
       });
     }
     return result;

package/src/persistence/validation.js

@@ -1,3 +1,34 @@
+import { validateAuthoredFacetLegend } from "../grammar/facets/legendIntent.js";
+import { AXIS_RESOURCE_CHANNELS } from "../core/vocabulary.js";
+import { cartesianAxisOwners, assertCartesianAxisSideAvailable } from "../selectors/axes.js";
+import { axisGraphicIds } from "../selectors/axes.js";
+
+
+
+import {findLayer} from '../selectors/layers.js';
+import {findCoordinate} from '../selectors/coordinates.js';
+import {resolveColorSizeMapping,normalizeColorSizeSymbol} from '../grammar/colorSizeLegend.js';
+import{validateLegendClip}from"../grammar/legendClip.js";
+import {validateLegendLayerOpacity}from"../grammar/legendOpacity.js";
+import { isSizeShapeChannels, resolveSizeShapeMapping } from "../grammar/legendCombinations.js";
+import { describeLegendBlock } from "../grammar/legendBlocks.js";
+import { localLegendPosition } from "../grammar/legendGroups.js";
+import { normalizeLegendBorderDash } from "../grammar/legendBorder.js";
+import { normalizeNumericDisplayLabelMap } from "../grammar/displayLabels.js";
+import { isContinuousSizeScaleType } from "../grammar/scales/size.js";
+import { validateGraphicItemLimit } from "../core/validation.js";
+import { LEGEND_TITLE_STYLE_KEYS, validateLegendTitleAlignment } from "../grammar/legendTitleStyle.js";
+import { validateGuideDash, normalizeGuideDashMap } from "../grammar/guideDash.js";
+import { validateAxisTextPlacement } from "../grammar/axisTextPlacement.js";
+import { validateAreaPaintConfig } from "../grammar/areaPaint.js";
+import { validateOptionObject, validateKeys, validatePositiveFinite, validateNonNegativeFinite, validateNonEmptyString, validateGeneratedItemLimit } from "../core/validation.js";
+import { validateRegressionFitStatistics, requireRegressionStatisticsSource, regressionStatisticsRows } from "../grammar/regression/statistics.js";
+import { resolveGraphicItemCapacity } from "../selectors/graphicCapacity.js";
+import { isContinuousColorScaleType } from "../grammar/scales/types.js";
+import { normalizeColorInterpolationOptions } from "../grammar/scales/color.js";
+import { normalizeTransformParameters } from "../grammar/scales/transformed.js";
+import { validateLegendGroupState } from "../grammar/legendGroups.js";
+import { normalizeGradientDirection, validateLegendGradient } from "../grammar/legendGradient.js";
 import { normalizeTextMetricProfile } from "../core/textMetricProfile.js";
 import { isPlainObject } from "../core/immutable.js";
 import { validateUserId } from "../core/identifiers.js";
@@ -130,6 +161,12 @@ export function validateProgramState(program, path) {
     }
     resources.set(referenceKind, entries);
     for (const resource of entries.values()) {
+      if (kind === "scale") {
+        normalizeColorInterpolationOptions(resource.interpolate, resource);
+        if (resource.type === "pow") normalizeTransformParameters("pow", {
+          ...(resource.exponent === undefined ? {} : {exponent:resource.exponent})
+        });
+      }
       for (const [key, value] of Object.entries(resource)) {
         if (key !== "id") validateSemanticProperties(program, value, `${kind}[${resource.id}].${key}`);
       }
@@ -141,7 +178,178 @@ export function validateProgramState(program, path) {
   }
   for (const key of ["resolvedScales", "materializationConfigs", "context"]) requireObject(program[key], `${path}.${key}`);
   for (const key of ["marks", "guides"]) requireObject(program.materializationConfigs[key], `${path}.materializationConfigs.${key}`);
+  if (program.compositionSpec?.type === "facet" && isPlainObject(program.compositionSpec.facet.guides.legend)) {
+    validateAuthoredFacetLegend(program, program.compositionSpec.facet.guides.legend);
+  }
   if (program.materializationConfigs.textMetrics !== undefined) normalizeTextMetricProfile(program.materializationConfigs.textMetrics);
+  for (const config of [
+    ...Object.values(program.guideConfigs.axis ?? {}).map(axis => axis.ticks),
+    ...["horizontal", "vertical"].map(direction => program.guideConfigs.grid?.[direction])
+  ]) {
+    if (config?.strokeDash !== undefined) validateGuideDash(config.strokeDash);
+    if (config?.strokeDashMap !== undefined) normalizeGuideDashMap(config.strokeDashMap, { reset: false });
+  }
+  for (const owner of cartesianAxisOwners(program)) {
+    const channel = owner.id;
+    const axis = owner.config;
+    if (axis?.frame !== undefined) {
+      exactKeys(axis.frame, ["offset"], `${path}.guides.axis.${channel}.frame`);
+      validateNonNegativeFinite(axis.frame.offset, "Axis frame offset");
+    }
+    if (axis?.labels !== undefined) validateAxisTextPlacement(axis.labels);
+    if (axis?.title !== undefined) validateAxisTextPlacement(axis.title, { title: true });
+  }
+  for (const id of Object.keys(program.guideConfigs.axis ?? {})) {
+    if (!AXIS_RESOURCE_CHANNELS.includes(id) && !Object.hasOwn(program.semanticSpec.guides.axis ?? {}, id)) {
+      throw invalidSnapshot("Named axis configs require their semantic owner.", path);
+    }
+  }
+  for (const [id, semanticAxis] of Object.entries(program.semanticSpec.guides.axis ?? {})) {
+    if (AXIS_RESOURCE_CHANNELS.includes(id)) continue;
+    validateUserId(id, "Axis id");
+    validateKeys(semanticAxis, ["channel", "position", "scale", "coordinate", "title"], "Stored named axis");
+    if (!["x", "y"].includes(semanticAxis.channel) ||
+        !(semanticAxis.channel === "x" ? ["bottom", "top"] : ["left", "right"]).includes(semanticAxis.position)) {
+      throw invalidSnapshot("Named axes require a Cartesian channel and compatible physical side.", path);
+    }
+    validateUserId(semanticAxis.scale, "Axis scale id");
+    validateUserId(semanticAxis.coordinate, "Axis coordinate id");
+    if (resources.get("coordinate").get(semanticAxis.coordinate)?.type !== "cartesian") {
+      throw invalidSnapshot("Named Cartesian axes require a Cartesian coordinate.", path);
+    }
+    const config = program.guideConfigs.axis?.[id];
+    requireObject(config, `${path}.guides.axis.${id}`);
+    validateKeys(config, ["binding", "frame", "line", "ticks", "labels", "title"], "Stored named axis config");
+    const components = ["line", "ticks", "labels", "title"];
+    if (!components.some(component => config[component] !== undefined)) {
+      throw invalidSnapshot("Named axes require at least one retained component.", path);
+    }
+    for (const [index, component] of components.entries()) {
+      const stored = config[component];
+      const graphic = program.graphicSpec.objects[axisGraphicIds(semanticAxis.channel, id)[index]];
+      if ((program.compositionSpec === undefined && (stored !== undefined) !== (graphic !== undefined)) ||
+          (stored !== undefined && (stored.position !== semanticAxis.position ||
+            stored.scale !== undefined && stored.scale !== semanticAxis.scale))) {
+        throw invalidSnapshot("Named axis components must share their owner's side and scale.", path);
+      }
+    }
+    if ((semanticAxis.title !== undefined) !== (config.title !== undefined)) {
+      throw invalidSnapshot("Named axis title meaning requires its retained title component.", path);
+    }
+    assertCartesianAxisSideAvailable(program, { id, channel: semanticAxis.channel,
+      coordinate: semanticAxis.coordinate, position: semanticAxis.position });
+  }
+  if (program.guideConfigs.legendGroups !== undefined) validateLegendGroupState(program.guideConfigs.legendGroups);
+  for (const [kind, config] of Object.entries(program.guideConfigs.legend ?? {})) {
+    validateLegendClip(kind,config);
+    if (localLegendPosition(config) !== undefined) {
+      const descriptor = describeLegendBlock(program, kind, config);
+      for (const [key, override] of Object.entries(config.blockOverrides)) {
+        if (override.position !== undefined && key !== descriptor.key) throw invalidSnapshot("Local position requires its existing block owner.", path);
+      }
+    }
+    for(const layer of config.symbol?.layers??[])validateLegendLayerOpacity(layer.opacity);
+    if(kind==='colorSize') {
+      if(config.combine!=='color-size')throw invalidSnapshot('Color-size legend requires its combined owner.',path);
+      const layer=findLayer(program,config.target);
+      const mapping=resolveColorSizeMapping({layer,scales:program.resolvedScales,pointConfig:program.markConfigs[layer?.id],coordinate:findCoordinate(program,layer?.coordinate)});
+      for(const key of ['target','field','fieldType','colorScale','sizeScale','domain'])if(JSON.stringify(config[key])!==JSON.stringify(mapping[key]))throw invalidSnapshot('Stale color-size mapping.',path);
+      const guide=semantic.guides.legend?.colorSize;
+      if(guide?.colorScale!==mapping.colorScale||guide?.sizeScale!==mapping.sizeScale||guide.title!==config.title)throw invalidSnapshot('Stale color-size semantic owner.',path);
+      requireObject(config.symbol,path);normalizeColorSizeSymbol(config.symbol);
+      if(config.symbol.type!=='point'||!Object.hasOwn(config.symbol,'strokeWidth')||!Object.hasOwn(config.symbol,'opacity'))throw invalidSnapshot('Color-size symbol requires point type.',path);
+      const sample=config.sampling;requireObject(sample,path);
+      exactKeys(sample,sample.mode==='values'?['mode','count','values']:['mode','count'],path);
+      if(!['auto','values'].includes(sample.mode)||!Number.isInteger(sample.count)||sample.count<2)throw invalidSnapshot('Invalid color-size samples.',path);
+      validateGeneratedItemLimit(sample.count,'Color-size samples');
+      if(sample.mode==='values'){
+        requireArray(sample.values,path);
+        if(!sample.values.length||sample.values.length>100||sample.values.some((v,i)=>!Number.isFinite(v)||i>0&&v<=sample.values[i-1]||v<Math.min(...mapping.domain)||v>Math.max(...mapping.domain)||[mapping.colorScale,mapping.sizeScale].some(id=>program.resolvedScales[id].type==='log'&&v<=0)))throw invalidSnapshot('Invalid exact color-size samples.',path);
+      }
+    } else if (config.combine !== undefined) {
+      if (config.combine !== "size-shape" || kind !== "series" || !isSizeShapeChannels(config.channels)) throw invalidSnapshot("Invalid combined legend owner.", path);
+      const layer = semantic.layers.find(layer=>layer.id===config.target);
+      const definition = resolveSizeShapeMapping({layer,scales:program.resolvedScales,
+        order:semantic.guides.legend?.series?.order,rows:resolveDatasetReference(program,layer.data).values});
+      if (!Array.isArray(config.sizeAreas) || config.sizeAreas.length !== definition.sizeAreas.length ||
+          config.sizeAreas.some((area,index)=>!Object.is(area,definition.sizeAreas[index]))) throw invalidSnapshot("Stale combined legend size mapping.", path);
+    }
+    if (config.gradientDirection !== undefined) {
+      if (!["gradient", "strokeGradient"].includes(kind)) throw invalidSnapshot("Gradient direction requires a gradient owner.", path);
+      normalizeGradientDirection(config.gradientDirection, "Stored gradient direction");
+    }
+    if (["gradient", "strokeGradient"].includes(kind) && config.representation !== "symbols" && !["top", "bottom"].includes(config.titlePosition)) {
+      throw invalidSnapshot("Gradient titlePosition requires top or bottom.", path);
+    }
+    if (config.border && Object.hasOwn(config.border, "strokeDash")) {
+      normalizeLegendBorderDash(config.border.strokeDash, "Stored legend border strokeDash");
+    }
+    if (["size","colorSize"].includes(kind) && config.blockOverrides !== undefined) {
+      for (const [key, override] of Object.entries(config.blockOverrides)) {
+        if (override.labelMap === undefined) continue;
+        if (key !== (kind==='colorSize'?'["color","size"]':'["size"]') || !isContinuousSizeScaleType(program.resolvedScales[kind==='colorSize'?config.sizeScale:config.scale]?.type)) {
+          throw invalidSnapshot("Numeric display labels require a continuous size legend block.", path);
+        }
+        normalizeNumericDisplayLabelMap(override.labelMap, "Stored size legend labelMap");
+      }
+    }
+    if (config.titleStyle !== undefined) {
+      validateOptionObject(config.titleStyle, LEGEND_TITLE_STYLE_KEYS, "Stored legend title style");
+      validateLegendTitleAlignment(config.titleStyle, config.titlePosition);
+    }
+    if (config.inferredOffset !== undefined && typeof config.inferredOffset !== "boolean") throw invalidSnapshot("Invalid legend offset inference.", path);
+    if (["gradient", "strokeGradient"].includes(kind) && config.representation !== "symbols") {
+      validateLegendGradient(config.gradient, "Stored legend gradient");
+    }
+    if (config.representation === undefined) continue;
+    if (kind !== "gradient" || !["symbols", "gradient"].includes(config.representation)) throw invalidSnapshot("Invalid continuous color legend representation.", path);
+    if (config.representation === "symbols") {
+      if (config.gradient !== undefined) throw invalidSnapshot("Symbol color legend cannot store gradient dimensions.", path);
+      requireObject(config.sampling, path);
+      const sample = config.sampling;
+      exactKeys(sample, sample.mode === "values" ? ["mode", "values", "count"] : ["mode", "count"], path);
+      if (!["auto", "values"].includes(sample.mode)) throw invalidSnapshot("Invalid color legend sample mode.", path);
+      if (!Number.isInteger(sample.count) || sample.count < 2) throw invalidSnapshot("Invalid color legend sample count.", path);
+      validateGeneratedItemLimit(sample.count, "Color legend sample count");
+      const scale = program.resolvedScales[config.scale];
+      if (!isContinuousColorScaleType(scale?.type)) throw invalidSnapshot("Sampled color legend requires a continuous color scale.", path);
+      if (sample.mode === "values") {
+        requireArray(sample.values, path);
+        if (!sample.values.length || sample.values.length > 100 || sample.values.some((value, index) => !Number.isFinite(value) || index > 0 && value <= sample.values[index - 1] || value < Math.min(...scale.domain) || value > Math.max(...scale.domain) || scale.type === "log" && value <= 0)) throw invalidSnapshot("Invalid exact color legend samples.", path);
+      }
+      requireObject(config.symbol, path);
+      validateKeys(config.symbol, ["type", "radius", "stroke", "strokeWidth"], "Stored sampled color symbol");
+      if (config.symbol.type !== "point") throw invalidSnapshot("Invalid sampled color symbol type.", path);
+      validatePositiveFinite(config.symbol.radius, "Stored sampled color radius");
+      validateNonNegativeFinite(config.symbol.strokeWidth, "Stored sampled color strokeWidth");
+      if (config.symbol.stroke !== undefined) validateNonEmptyString(config.symbol.stroke, "Stored sampled color stroke");
+      if (!["left", "right", "top", "bottom", "top-left", "top-right", "bottom-left", "bottom-right"].includes(config.position) || !["horizontal", "vertical"].includes(config.direction) || config.layout !== "edge" || !["left", "center", "right"].includes(config.align) || !["top", "left"].includes(config.titlePosition) || config.columns !== undefined && (!Number.isInteger(config.columns) || config.columns < 1)) throw invalidSnapshot("Invalid sampled color item layout.", path);
+      validatePositiveFinite(config.itemGap, "Stored sampled color itemGap");
+      validateNonNegativeFinite(config.offset, "Stored sampled color offset");
+    } else if (["sampling", "symbol", "columns", "direction", "layout"].some(key => config[key] !== undefined)) throw invalidSnapshot("Gradient color legend cannot store symbol representation settings.", path);
+  }
+
+  const regressionFits = program.materializationConfigs.regressionFits ?? {};
+  requireObject(regressionFits, `${path}.materializationConfigs.regressionFits`);
+  for (const [id, cache] of Object.entries(regressionFits)) {
+    const dataset = resources.get("data").get(id);
+    validateRegressionFitStatistics(cache, dataset, resources.get("data").get(dataset?.source));
+  }
+  for (const dataset of semantic.datasets) {
+    if (dataset.transform?.[0]?.type !== "regressionStatistics") continue;
+    const fit = resources.get("data").get(dataset.source);
+    requireRegressionStatisticsSource(fit);
+    if (regressionFits[fit.id] === undefined) throw invalidSnapshot("Regression statistics requires its linear fit cache.", path);
+    if (dataset.values !== undefined) {
+      const expected = regressionStatisticsRows(regressionFits[fit.id], fit);
+      if (dataset.values.length !== expected.length || dataset.values.some((row, index) =>
+        !isPlainObject(row) || Object.keys(row).length !== Object.keys(expected[index]).length ||
+        Object.entries(expected[index]).some(([key, value]) => !Object.hasOwn(row, key) || !Object.is(row[key], value)))) {
+        throw invalidSnapshot("Regression statistics values do not match their linear fit cache.", path);
+      }
+    }
+  }
+
   const selections = program.materializationConfigs.selections ?? {};
   requireObject(selections, `${path}.materializationConfigs.selections`);
   for (const [id, selection] of Object.entries(selections)) {
@@ -161,12 +369,19 @@ export function validateProgramState(program, path) {
     requireObject(scale, `${path}.resolvedScales.${id}`);
     requireArray(scale.domain, `${path}.resolvedScales.${id}.domain`);
     requireArray(scale.range, `${path}.resolvedScales.${id}.range`);
+    normalizeColorInterpolationOptions(scale.interpolate, scale);
+    if (scale.type === "pow") normalizeTransformParameters("pow", {
+      ...(scale.exponent === undefined ? {} : {exponent:scale.exponent})
+    });
     if (!resources.get("scale").has(id) || scale.type !== resources.get("scale").get(id).type) {
       throw invalidSnapshot(`Resolved scale "${id}" has no matching semantic owner/type.`, path);
     }
   }
   for (const id of Object.keys(program.markConfigs)) {
     if (!resources.get("mark").has(id)) throw invalidSnapshot(`Mark config "${id}" has no layer owner.`, path);
+    if (resources.get("mark").get(id).mark.type === "area") {
+      validateAreaPaintConfig(program.markConfigs[id]);
+    }
   }
   for (const kind of ["data", "mark"]) {
     const visited = new Set();
@@ -182,4 +397,9 @@ export function validateProgramState(program, path) {
     for (const resource of resources.get(kind).values()) visit(resource);
   }
   validateGraphic(program.graphicSpec, `${path}.graphicSpec`);
+  for (const [id, graphic] of Object.entries(program.graphicSpec.objects)) {
+    if (graphic.items !== undefined) validateGraphicItemLimit(graphic.items.length, resolveGraphicItemCapacity(program, {
+      id, label: "Graphic collection length"
+    }));
+  }
 }