ggaction 0.0.15 → 0.0.17

package/src/layout/legendItems.js

@@ -3,7 +3,7 @@ import { alignLegendStart, resolveLegendGrid } from "./legend.js";
 
 // Measure item content before choosing its edge. Family owners supply the
 // sample dimensions and formatted labels; this module does not inspect scales.
-export function resolveLegendItemLayout(plot, config, labels, symbol, canvas) {
+export function resolveLegendItemLayout(plot, config, labels, symbol, canvas, profile) {
   const strokes = labels.map((_, index) => Array.isArray(symbol.strokeWidth)
     ? symbol.strokeWidth[index] : symbol.strokeWidth ?? 0);
   const sampleBounds = labels.map((_, index) => symbol.itemBounds?.[index] ?? {
@@ -19,17 +19,17 @@ export function resolveLegendItemLayout(plot, config, labels, symbol, canvas) {
     ...sampleBounds.map(bounds => 2 * Math.max(-bounds.top, bounds.bottom)));
   const side = ["left", "right"].includes(config.position);
   const titleVisible = config.titleVisible !== false;
-  const titleWidth = titleVisible ? measureTextWidth(config.title, config.titleStyle) : 0;
+  const titleWidth = titleVisible ? measureTextWidth(config.title, config.titleStyle, profile) : 0;
   const titleHeight = titleVisible ? config.titleStyle.fontSize : 0;
   const itemWidth = sampleWidth + config.labels.offset + Math.max(...labels.map(
-    text => measureTextWidth(text, config.labels)
+    text => measureTextWidth(text, config.labels, profile)
   ));
   let symbolX;
   let labelX;
   let itemY;
   let title;
   if (config.layout === "legacy-bottom") {
-    const widths = labels.map(text => sampleWidth + config.labels.offset + measureTextWidth(text, config.labels));
+    const widths = labels.map(text => sampleWidth + config.labels.offset + measureTextWidth(text, config.labels, profile));
     const width = widths.reduce((sum, value) => sum + value, 0) + config.itemGap * (labels.length - 1);
     const x = config.align === "center" ? (canvas.width - width) / 2 : alignLegendStart(plot, width, config.align);
     let cursor = x;
@@ -54,7 +54,7 @@ export function resolveLegendItemLayout(plot, config, labels, symbol, canvas) {
     itemY = labels.map((_, index) => firstY + index * pitch);
     title = { x, y: plot.y + 20, align: "left" };
   } else {
-    const grid = resolveLegendGrid({ ...config, domain: labels }, sampleWidth, labels.length, sampleHeight);
+    const grid = resolveLegendGrid({ ...config, domain: labels }, sampleWidth, labels.length, sampleHeight, profile);
     const inline = config.titlePosition === "left" && titleVisible;
     const prefix = inline ? titleWidth + 20 : 0;
     const width = inline ? prefix + grid.gridWidth : Math.max(titleWidth, grid.gridWidth);
@@ -79,7 +79,7 @@ export function resolveLegendItemLayout(plot, config, labels, symbol, canvas) {
   }
   const textBounds = (x, y, text, style, align = "left") => resolveTextBounds({
     x, y, text, ...style, textAlign: align, textBaseline: "middle"
-  });
+  }, profile);
   const bounds = [
     ...(titleVisible ? [textBounds(title.x, title.y, config.title, config.titleStyle, title.align)] : []),
     ...labels.map((label, index) => textBounds(labelX[index], itemY[index], label, config.labels)),

package/src/layout/text.js

@@ -5,12 +5,12 @@ export {
   resolveTextBounds
 } from "../core/textMetrics.js";
 
-function wrapCodePoints(text, maxWidth, style) {
+function wrapCodePoints(text, maxWidth, style, profile) {
   const lines = [];
   let line = "";
   for (const codePoint of [...text]) {
     const candidate = line + codePoint;
-    if (line !== "" && measureTextWidth(candidate, style) > maxWidth) {
+    if (line !== "" && measureTextWidth(candidate, style, profile) > maxWidth) {
       lines.push(line);
       line = codePoint;
     } else {
@@ -21,22 +21,22 @@ function wrapCodePoints(text, maxWidth, style) {
   return lines;
 }
 
-function wrapWords(text, maxWidth, style) {
+function wrapWords(text, maxWidth, style, profile) {
   const lines = [];
   let line = "";
   for (const word of text.trim().split(/\s+/u)) {
-    if (measureTextWidth(word, style) > maxWidth) {
+    if (measureTextWidth(word, style, profile) > maxWidth) {
       if (line !== "") {
         lines.push(line);
         line = "";
       }
-      const fragments = wrapCodePoints(word, maxWidth, style);
+      const fragments = wrapCodePoints(word, maxWidth, style, profile);
       lines.push(...fragments.slice(0, -1));
       line = fragments.at(-1);
       continue;
     }
     const candidate = line === "" ? word : `${line} ${word}`;
-    if (line !== "" && measureTextWidth(candidate, style) > maxWidth) {
+    if (line !== "" && measureTextWidth(candidate, style, profile) > maxWidth) {
       lines.push(line);
       line = word;
     } else {
@@ -50,7 +50,8 @@ function wrapWords(text, maxWidth, style) {
 export function wrapText(text, {
   maxWidth,
   mode = "word",
-  style
+  style,
+  profile
 } = {}) {
   if (maxWidth === undefined) return [text];
   if (!Number.isFinite(maxWidth) || maxWidth <= 0) {
@@ -60,6 +61,6 @@ export function wrapText(text, {
     throw new Error(`Unsupported text wrap mode "${mode}".`);
   }
   return mode === "word"
-    ? wrapWords(text, maxWidth, style)
-    : wrapCodePoints(text, maxWidth, style);
+    ? wrapWords(text, maxWidth, style, profile)
+    : wrapCodePoints(text, maxWidth, style, profile);
 }

package/src/layout/title.js

@@ -4,16 +4,16 @@ function lineCenters(lines, style, lineHeight, start) {
   return lines.map((_, index) => start + style.fontSize / 2 + index * lineHeight);
 }
 
-export function buildTitleReadingBlock({ text, subtitle }, config) {
+export function buildTitleReadingBlock({ text, subtitle }, config, profile) {
   const titleLines = wrapText(text, {
     maxWidth: config.maxWidth,
     mode: config.wrap,
-    style: config.titleStyle
+    style: config.titleStyle, profile
   });
   const subtitleLines = subtitle === undefined ? [] : wrapText(subtitle, {
     maxWidth: config.maxWidth,
     mode: config.wrap,
-    style: config.subtitleStyle
+    style: config.subtitleStyle, profile
   });
   const titleLineHeight = config.lineHeight ?? config.titleStyle.fontSize * 1.2;
   const subtitleLineHeight = config.lineHeight ??
@@ -36,8 +36,8 @@ export function buildTitleReadingBlock({ text, subtitle }, config) {
     ? titleBottom
     : subtitleCenters.at(-1) + config.subtitleStyle.fontSize / 2;
   const widths = [
-    ...titleLines.map(line => measureTextWidth(line, config.titleStyle)),
-    ...subtitleLines.map(line => measureTextWidth(line, config.subtitleStyle))
+    ...titleLines.map(line => measureTextWidth(line, config.titleStyle, profile)),
+    ...subtitleLines.map(line => measureTextWidth(line, config.subtitleStyle, profile))
   ];
   return {
     titleLines,
@@ -61,7 +61,7 @@ export function alignedTextAnchor(start, length, align) {
   return start + length;
 }
 
-function axisAlignedTextBounds({ x, y, text, style, align, rotation }) {
+function axisAlignedTextBounds({ x, y, text, style, align, rotation }, profile) {
   return resolveTextBounds({
     x,
     y,
@@ -70,7 +70,7 @@ function axisAlignedTextBounds({ x, y, text, style, align, rotation }) {
     textAlign: align,
     textBaseline: "middle",
     rotation
-  });
+  }, profile);
 }
 
 function unionBounds(bounds) {
@@ -82,7 +82,7 @@ function unionBounds(bounds) {
   }), { left: Infinity, right: -Infinity, top: Infinity, bottom: -Infinity });
 }
 
-export function resolveTitleComponentBounds(component, style) {
+export function resolveTitleComponentBounds(component, style, profile) {
   return unionBounds(component.lines.map((text, index) => axisAlignedTextBounds({
     x: Array.isArray(component.x) ? component.x[index] : component.x,
     y: Array.isArray(component.y) ? component.y[index] : component.y,
@@ -90,7 +90,7 @@ export function resolveTitleComponentBounds(component, style) {
     style,
     align: component.textAlign,
     rotation: component.rotation
-  })));
+  }, profile)));
 }
 
 export function unionTitleBounds(bounds) {

package/src/materialization/bars/resolve.js

@@ -4,6 +4,7 @@ import { findLayer } from "../../selectors/layers.js";
 import { findSemanticScale } from "../../selectors/scales.js";
 import { BAR_GRAINS, resolveBarGrain } from "../../grammar/bars/policy.js";
 import { requestedStrokeDetails } from "../../grammar/strokeStyle.js";
+import { applyItemMissingPolicy } from "../../grammar/itemMissing.js";
 
 export const DEFAULT_BAR_FILL = DEFAULT_COLORS.mark;
 export const DEFAULT_BAR_STROKE = "white";
@@ -37,10 +38,11 @@ export function requireCompleteBar(program, id) {
   if (layer?.mark?.type !== "bar") {
     throw new Error(`Unknown bar mark "${id}".`);
   }
-  const dataset = findDataset(program, layer.data);
-  if (dataset === undefined) {
+  const sourceDataset = findDataset(program, layer.data);
+  if (sourceDataset === undefined) {
     throw new Error(`Bar mark "${id}" requires an existing dataset.`);
   }
+  const dataset = applyItemMissingPolicy(layer, sourceDataset);
   const graphic = program.graphicSpec.objects[id];
   const roundedCollection = graphic?.type === "collection" &&
     Object.hasOwn(program.markConfigs[id]?.barAppearance ?? {}, "cornerRadius") &&

package/src/materialization/facetGuides/placement.js

@@ -92,7 +92,7 @@ function attachParentLegend(program, prepared, plot, layout) {
 }
 
 function assertSharedLegendFits(program, id, layout, plot) {
-  const bounds = resolveConcreteGraphicBounds(program.graphicSpec, id);
+  const bounds = resolveConcreteGraphicBounds(program.graphicSpec, id, program.materializationConfigs.textMetrics);
   if (bounds === undefined) {
     throw new Error("Facet shared legend requires measurable concrete bounds.");
   }

package/src/materialization/facetGuides/preparation.js

@@ -197,7 +197,7 @@ export function prepareSharedFacetLegend(program) {
   if (roots.length === 0) {
     throw new Error("Shared facet legend has no concrete guide graphics.");
   }
-  const bounds = unionConcreteGraphicBounds(source.graphicSpec, roots);
+  const bounds = unionConcreteGraphicBounds(source.graphicSpec, roots, source.materializationConfigs.textMetrics);
   if (bounds === undefined) {
     throw new Error("Shared facet legend has no measurable concrete bounds.");
   }

package/src/materialization/facetHeaders.js

@@ -139,13 +139,13 @@ function roleDescriptors(program, headers) {
   return [...columns, ...rows];
 }
 
-function laneThickness(descriptors, role) {
+function laneThickness(descriptors, role, profile) {
   const visible = descriptors.filter(item => item.role === role && item.text !== "");
   if (visible.length === 0) return 0;
   if (role === "column") {
     return Math.max(...visible.map(item => item.config.fontSize + item.config.offset));
   }
-  return Math.max(...visible.map(item => measureTextWidth(item.text, item.config) +
+  return Math.max(...visible.map(item => measureTextWidth(item.text, item.config, profile) +
     item.config.offset));
 }
 
@@ -163,7 +163,7 @@ export function prepareFacetHeaders(program, headersConfig) {
   };
   if (headers.mode === "roles") {
     const column = resolveFacetHeaderConfig(headers, "column");
-    const columnThickness = laneThickness(descriptors, "column");
+    const columnThickness = laneThickness(descriptors, "column", program.materializationConfigs.textMetrics);
     if (program.compositionSpec.facet.grid === undefined) {
       for (const descriptor of descriptors) {
         if (descriptor.text !== "") {
@@ -176,7 +176,7 @@ export function prepareFacetHeaders(program, headersConfig) {
     } else {
       headerLayout.outer[column.side] = columnThickness;
       const row = resolveFacetHeaderConfig(headers, "row");
-      headerLayout.outer[row.side] = laneThickness(descriptors, "row");
+      headerLayout.outer[row.side] = laneThickness(descriptors, "row", program.materializationConfigs.textMetrics);
     }
   }
   return { headers, descriptors, headerLayout };
@@ -287,10 +287,10 @@ function styledItem(item) {
   };
 }
 
-function assertRoleHeadersFit(records, items, layout) {
+function assertRoleHeadersFit(records, items, layout, profile) {
   const bounds = items.map((item, index) => records[index].descriptor.text === ""
     ? undefined
-    : resolveTextBounds(item.properties));
+    : resolveTextBounds(item.properties, profile));
   for (const [index, current] of bounds.entries()) {
     if (current === undefined) continue;
     if (current.left < -1e-9 || current.right > layout.width + 1e-9 ||
@@ -305,11 +305,11 @@ function assertRoleHeadersFit(records, items, layout) {
   }
 }
 
-function assertLegacyHeadersFit(items, layout, plotById) {
+function assertLegacyHeadersFit(items, layout, plotById, profile) {
   const previous = [];
   for (let index = 0; index < items.length; index += 1) {
     if (items[index].properties.text === "") continue;
-    const bounds = resolveTextBounds(items[index].properties);
+    const bounds = resolveTextBounds(items[index].properties, profile);
     const cell = layout.children[index];
     const plot = plotById.get(cell.id);
     if (bounds.left < 0 || bounds.right > layout.width ||
@@ -325,6 +325,7 @@ function assertLegacyHeadersFit(items, layout, plotById) {
 }
 
 export function materializeFacetHeaders(program, layout, plots, prepared) {
+  const profile = program.materializationConfigs.textMetrics;
   const cells = new Map(layout.children.map(cell => [cell.id, cell]));
   const plotById = new Map(plots.map(plot => [plot.id, plot]));
   const records = prepared.descriptors.map(descriptor => {
@@ -335,9 +336,9 @@ export function materializeFacetHeaders(program, layout, plots, prepared) {
   });
   const items = records.map(styledItem);
   if (prepared.headers.mode === "legacy") {
-    assertLegacyHeadersFit(items, layout, plotById);
+    assertLegacyHeadersFit(items, layout, plotById, profile);
   } else {
-    assertRoleHeadersFit(records, items, layout);
+    assertRoleHeadersFit(records, items, layout, profile);
   }
   const id = `${program.compositionSpec.id}-headers`;
   return program

package/src/materialization/guides/layout.js

@@ -4,12 +4,12 @@ import { axisGraphicIds, legendResourcePolicies } from "./resources.js";
 
 // Only domain-owned guides participate. Extension primitives may deliberately
 // overlap, and a combined categorical/size legend is one occupied group.
-export function resolveGuideCollisionBlocks(graphicSpec, guideConfigs, titleConfig) {
+export function resolveGuideCollisionBlocks(graphicSpec, guideConfigs, titleConfig, profile) {
   const blocks = [];
   const append = (id, kind, position, ids) => {
     if (position === undefined) return;
     const existing = ids.filter(id => graphicSpec.objects[id] !== undefined);
-    const bounds = unionConcreteGraphicBounds(graphicSpec, existing);
+    const bounds = unionConcreteGraphicBounds(graphicSpec, existing, profile);
     if (bounds !== undefined) blocks.push({ id, kind, position, bounds });
   };
   append("chart title", "title", titleConfig?.position, ["chartTitle", "chartSubtitle"]);
@@ -46,7 +46,7 @@ export function withGuideLayoutTransaction(program, apply) {
     context.deferGuideLayoutValidation = program.context.deferGuideLayoutValidation;
   }
   const next = result._clone({ context });
-  assertGuideCollisionBlocks(resolveGuideCollisionBlocks(next.graphicSpec, next.guideConfigs, next.titleConfig));
+  assertGuideCollisionBlocks(resolveGuideCollisionBlocks(next.graphicSpec, next.guideConfigs, next.titleConfig, next.materializationConfigs.textMetrics));
   return next;
 }
 

package/src/materialization/revisionIdentity.js

@@ -0,0 +1,19 @@
+let activeReplacements;
+
+export function withLogicalDataReplacements(replacements, operation) {
+  const previous = activeReplacements;
+  activeReplacements = replacements;
+  try {
+    return operation();
+  } finally {
+    activeReplacements = previous;
+  }
+}
+
+export function comparableDataIdentity(id) {
+  if (activeReplacements === undefined) return id;
+  for (const [before, after] of activeReplacements) {
+    if (after === id) return before;
+  }
+  return id;
+}

package/src/materialization/scaleGuideDependencies.js

@@ -18,6 +18,16 @@ const GRIDS = Object.freeze([
   Object.freeze({ role: "radial", op: "rematerializeRadialGrid" })
 ]);
 
+export function planAxisTickGridRematerialization(program, channel) {
+  const ticks = program.guideConfigs.axis?.[channel]?.ticks;
+  const role = channel === "x" ? "vertical" : "horizontal";
+  const config = program.guideConfigs.grid?.[role];
+  return buildMaterializationPlan({ guides:
+    config?.inferredValues === true && config.scale === ticks?.scale
+      ? GRIDS.filter(grid => grid.role === role).map(grid => ({ op: grid.op })) : []
+  });
+}
+
 function usesPositionalScale(program, id) {
   return program.semanticSpec.layers.some(layer =>
     !isSourceOwnedText(layer) && (

package/src/materialization/scales/resolve.js

@@ -35,6 +35,36 @@ import { resolveOffsetScalePolicy } from "./policies/offset.js";
 import { resolveBinnedPositionDomain } from "./policies/binnedPosition.js";
 import { resolveSeriesLayoutDomain } from "./policies/series.js";
 import { OFFSET_POSITION_CHANNELS } from "../../core/vocabulary.js";
+import { annotateError } from "../../core/diagnostics.js";
+import { cloneAndFreeze } from "../../core/immutable.js";
+import { comparableDataIdentity } from "../revisionIdentity.js";
+
+const bindingSignatures = new WeakMap();
+
+function scaleBindingSignature(channel, consumers, { comparable = false } = {}) {
+  return consumers.map(consumer => ({
+    channel: consumer.channel ?? channel,
+    coordinate: consumer.layer.coordinate,
+    data: comparable
+      ? comparableDataIdentity(consumer.layer.data)
+      : consumer.layer.data,
+    field: consumer.encoding.field,
+    datum: consumer.encoding.datum,
+    fieldType: consumer.encoding.fieldType,
+    temporalUnit: consumer.encoding.temporalUnit,
+    aggregate: consumer.encoding.aggregate,
+    bin: consumer.encoding.bin
+  })).sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+}
+
+export function rememberResolvedScaleBinding(resolvedScale, channel, consumers) {
+  if (resolvedScale !== undefined) {
+    bindingSignatures.set(
+      resolvedScale,
+      cloneAndFreeze(scaleBindingSignature(channel, consumers))
+    );
+  }
+}
 
 function resolveDefaultDomain({
   scale,
@@ -206,12 +236,22 @@ export function resolveScaleMaterialization(options) {
     .flatMap(item => item.values)
     .filter(value => value !== undefined);
   const preserved = resolvedScales[id]?.domain;
+  const bindingSignature = scaleBindingSignature(channel, consumers);
+  const comparableBindingSignature = scaleBindingSignature(channel, consumers, {
+    comparable: true
+  });
+  const priorSignature = resolvedScales[id] === undefined
+    ? undefined
+    : bindingSignatures.get(resolvedScales[id]);
+  const samePreservedMeaning = priorSignature !== undefined &&
+    JSON.stringify(priorSignature) === JSON.stringify(comparableBindingSignature);
   if (
     scale.domain === "auto" &&
     Array.isArray(preserved) &&
-    consumers.some(({ layer }) =>
+    resolvedScales[id]?.type === scale.type &&
+    (consumers.some(({ layer }) =>
       markConfigs?.[layer.id]?.markFilter?.empty === true
-    )
+    ) || (scale.emptyDomain === "preserve" && allValues.length === 0 && samePreservedMeaning))
   ) {
     return resolveScaleMaterialization({
       ...options,
@@ -222,6 +262,27 @@ export function resolveScaleMaterialization(options) {
       }))
     });
   }
+  if (
+    scale.domain === "auto" && allValues.length === 0 &&
+    scale.emptyDomain === "preserve" && Array.isArray(preserved) && !samePreservedMeaning
+  ) {
+    throw annotateError(new Error(`Scale "${id}" requires an explicit domain because its binding changed.`), {
+      code: "incompatible-resource",
+      operation: "rematerializeScale",
+      optionPath: "domain",
+      resourceId: id,
+      reason: "domain-required"
+    });
+  }
+  if (scale.domain === "auto" && allValues.length === 0) {
+    throw annotateError(new Error(`Scale "${id}" requires an explicit domain for empty data.`), {
+      code: "incompatible-resource",
+      operation: "rematerializeScale",
+      optionPath: "domain",
+      resourceId: id,
+      reason: "domain-required"
+    });
+  }
   if (channel === "size") {
     return resolveSizeScale({ ...scale, values: allValues });
   }
@@ -389,7 +450,9 @@ export function resolveScaleMaterialization(options) {
       };
     }
   }
-  return scale.reverse === true
+  const finalScale = cloneAndFreeze(scale.reverse === true
     ? reverseResolvedScale(resolvedScale)
-    : resolvedScale;
+    : resolvedScale);
+  bindingSignatures.set(finalScale, cloneAndFreeze(bindingSignature));
+  return finalScale;
 }

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

@@ -102,7 +102,7 @@ function collectionBounds(program, items) {
   const bounds = unionConcreteGraphicBounds(
     program.graphicSpec,
     items.map(item => item.id)
-  );
+  , program.materializationConfigs.textMetrics);
   if (bounds === undefined) return {};
   const { left, top, right, bottom } = bounds;
   return { x: left, y: top, width: right - left, height: bottom - top };

package/src/materialization/text.js

@@ -9,6 +9,7 @@ import { formatTextValue } from "../grammar/text.js";
 import { normalizePositionDatum } from "../grammar/positionDatum.js";
 import { mapOrdinalPositionValues } from "../grammar/scales/index.js";
 import { findDataset } from "../selectors/datasets.js";
+import { applyItemMissingPolicy } from "../grammar/itemMissing.js";
 import { findCoordinate } from "../selectors/coordinates.js";
 import { findLayer } from "../selectors/layers.js";
 import { unionConcreteGraphicBounds } from
@@ -214,7 +215,7 @@ function pointPlacementGeometry(program, source, item) {
   const objectBounds = unionConcreteGraphicBounds(
     program.graphicSpec,
     item.graphicIds
-  );
+  , program.materializationConfigs.textMetrics);
   const corners = objectBounds === undefined ? [] : [
     { x: objectBounds.left, y: objectBounds.top },
     { x: objectBounds.right, y: objectBounds.top },
@@ -391,7 +392,7 @@ function resolveSourceTextItems(program, layer, config) {
         dx: resolvedConfig.dx,
         dy: resolvedConfig.dy
       }
-    });
+    }, program.materializationConfigs.textMetrics);
     if (!resolved.visible) return [];
     if (
       resolved.anchor.startsWith("outside") &&
@@ -414,10 +415,11 @@ function resolveSourceTextItems(program, layer, config) {
 }
 
 function resolveRowTextItems(program, layer, config) {
-  const dataset = findDataset(program, layer.data);
-  if (dataset === undefined) {
+  const sourceDataset = findDataset(program, layer.data);
+  if (sourceDataset === undefined) {
     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 length = encodings.some(encoding => encoding !== undefined && Object.hasOwn(encoding, "field"))
     ? dataset.values.length

package/src/materialization/typography.js

@@ -0,0 +1,31 @@
+import { applyMaterializationPlan, buildMaterializationPlan } from "./planner.js";
+import { withGuideLayoutTransaction } from "./guides/layout.js";
+
+// Font tokens and measured-width profiles invalidate the same existing owners.
+// Incomplete text remains incomplete until its own prerequisites are authored.
+export function rematerializeTypography(program) {
+  if (program.compositionSpec !== undefined) {
+    return program.compositionSpec.type === "facet" ? program.materializeComposition() : program;
+  }
+  const exists = (id, op) => program.graphicSpec.objects[id] !== undefined && typeof program[op] === "function";
+  const marks = program.semanticSpec.layers
+    .filter(layer => layer.mark?.type === "text" && exists(layer.id, "rematerializeTextMark"))
+    .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 });
+  const parallel = program.guideConfigs.axis?.parallel?.axes;
+  if (parallel !== undefined && typeof program.rematerializeParallelAxes === "function") {
+    guides.push({ op: "rematerializeParallelAxes", args: { target: parallel.target } });
+  }
+  if (Object.keys(program.guideConfigs.legend ?? {}).length > 0 && typeof program.rematerializeLegend === "function") {
+    guides.push({ op: "rematerializeLegend" });
+  }
+  const layout = exists("chartTitle", "rematerializeTitle") ? [{ op: "rematerializeTitle" }] : [];
+  return withGuideLayoutTransaction(program, next =>
+    applyMaterializationPlan(next, buildMaterializationPlan({ marks, guides, layout })));
+}

package/src/mcp/cli.js

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 
-import { runGgactionMcpServer } from "./server.js";
-
 try {
+  const { runGgactionMcpServer } = await import("./server.js");
   await runGgactionMcpServer();
 } catch (error) {
-  const message = error instanceof Error ? error.message : String(error);
+  const message = error.code === "ERR_MODULE_NOT_FOUND" &&
+    error.message.includes("@modelcontextprotocol/sdk")
+    ? "MCP requires @modelcontextprotocol/sdk. Install it with: npm install ggaction @modelcontextprotocol/sdk"
+    : error instanceof Error ? error.message : String(error);
   process.stderr.write(`ggaction MCP failed: ${message}\n`);
   process.exitCode = 1;
 }

package/src/persistence/codec.js

@@ -0,0 +1,65 @@
+import { isPlainObject } from "../core/immutable.js";
+import { annotateError } from "../core/diagnostics.js";
+
+export function invalidSnapshot(message, optionPath) {
+  return annotateError(new TypeError(message), { code: "unsupported-format", optionPath });
+}
+
+export function encodeValue(value, path = "payload", ancestors = new WeakSet()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (value === undefined) return ["undefined"];
+  if (typeof value === "bigint") return ["bigint", value.toString()];
+  if (typeof value === "number") {
+    return Number.isFinite(value) && !Object.is(value, -0) ? value
+      : ["number", Object.is(value, -0) ? "-0" : String(value)];
+  }
+  if (typeof value !== "object") throw invalidSnapshot(`Cannot serialize ${typeof value} at ${path}.`, path);
+  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);
+  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)) {
+    throw invalidSnapshot(`Cannot serialize hidden or named array properties at ${path}.`, path);
+  }
+  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)])];
+  ancestors.delete(value);
+  return result;
+}
+
+export function decodeValue(value, path = "payload") {
+  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 === "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);
+  if (tag === "number" && typeof payload === "string" && ["NaN", "Infinity", "-Infinity", "-0"].includes(payload)) {
+    return payload === "-0" ? -0 : Number(payload);
+  }
+  if (tag === "array" && Array.isArray(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}]`);
+    });
+    return result;
+  }
+  if (tag === "object" && Array.isArray(payload)) {
+    const result = {};
+    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
+      });
+    }
+    return result;
+  }
+  return invalid();
+}