ggaction 0.0.24 → 0.0.26

package/src/materialization/guides/visibility.js

@@ -0,0 +1,105 @@
+import { cloneAndFreeze, isPlainObject } from "../../core/immutable.js";
+import { axisGraphicIds } from "../../selectors/axes.js";
+import { legendResourcePolicies } from "./resources.js";
+
+// Visibility is retained guide intent. Paint is derived, not a deletion of the
+// guide or its typography. Keeping geometry also preserves relative anchors.
+export function splitGuideVisibility(args, parts = ["line", "ticks", "labels", "title"]) {
+  if (!isPlainObject(args)) return { args, visibility: {} };
+  if (args.ticksAndLabels !== undefined && (args.ticks !== undefined || args.labels !== undefined)) throw new Error("Axis edit cannot combine ticksAndLabels with ticks or labels.");
+  const out = { ...args }, visibility = {};
+  const take = (object, key) => {
+    if (!Object.hasOwn(object, "visible")) return;
+    if (typeof object.visible !== "boolean") throw new TypeError(`${key}.visible must be a boolean.`);
+    visibility[key] = object.visible; delete object.visible;
+  };
+  take(out, "all");
+  for (const part of parts) if (isPlainObject(out[part])) {
+    out[part] = { ...out[part] }; take(out[part], part);
+    if (Object.hasOwn(visibility, part) && !Object.keys(out[part]).length) delete out[part];
+  }
+  if (isPlainObject(out.ticksAndLabels)) {
+    out.ticksAndLabels = { ...out.ticksAndLabels };
+    for (const part of ["ticks", "labels"]) if (isPlainObject(out.ticksAndLabels[part])) {
+      out.ticksAndLabels[part] = { ...out.ticksAndLabels[part] };
+      take(out.ticksAndLabels[part], part);
+      if (Object.hasOwn(visibility, part) && !Object.keys(out.ticksAndLabels[part]).length) delete out.ticksAndLabels[part];
+    }
+    if ((Object.hasOwn(visibility, "ticks") || Object.hasOwn(visibility, "labels")) && !Object.keys(out.ticksAndLabels).length) delete out.ticksAndLabels;
+  }
+  return { args: out, visibility };
+}
+
+export function patchGuideVisibility(program, family, id, patch) {
+  if (!Object.keys(patch).length) return program;
+  const config = program.guideConfigs[family]?.[id];
+  if (!config) throw new Error(`Visibility requires an existing ${family} guide.`);
+  return program._withMaterializationConfig(["guides", family, id], {
+    ...config, visibility: { ...config.visibility, ...patch }
+  });
+}
+
+function paint(program, restore) {
+  const retained = program.materializationConfigs.guideVisibilityPaint ?? {};
+  const backups = {}, objects = { ...program.graphicSpec.objects };
+  let changed = false; const visited = new Set();
+  function visit(id, hide = false) {
+    const object = objects[id]; if (!object || visited.has(id)) return; visited.add(id);
+    const patch = (item, key) => {
+      const previous = retained[id]?.[key];
+      if (restore && previous === undefined || !restore && !hide) return item;
+      const properties = { ...item.properties };
+      if (restore) {
+        if (previous.opacity === null) delete properties.opacity;
+        else properties.opacity = previous.opacity;
+      } else {
+        (backups[id] ??= {})[key] = { opacity: properties.opacity ?? null };
+        properties.opacity = 0;
+      }
+      changed = true; return { ...item, properties };
+    };
+    let next = object;
+    if (object.items) next = { ...next, items: object.items.map(item => patch(item, item.id)) };
+    else if (object.type !== "canvas" && object.properties) next = patch(next, id);
+    objects[id] = next;
+    for (const child of object.children ?? []) visit(child, hide);
+  }
+  if (restore) {
+    if (!Object.keys(retained).length) return program;
+    for (const id of Object.keys(retained)) visit(id);
+  } else {
+    const parts = ["line", "ticks", "labels", "title"];
+    for (const [id, config] of Object.entries(program.guideConfigs.axis ?? {})) {
+      const channel = program.semanticSpec.guides.axis?.[id]?.channel ?? id;
+      if (channel === "parallel") continue;
+      const visibility = config.visibility ?? {};
+      axisGraphicIds(channel, id).forEach((graphic, index) => {
+        if (visibility.all === false || visibility[parts[index]] === false) visit(graphic, true);
+      });
+    }
+    for (const policy of legendResourcePolicies()) {
+      const visibility = program.guideConfigs.legend?.[policy.kind]?.visibility ?? {};
+      for (const id of policy.graphicIds) if (visibility.all === false ||
+        id.endsWith("Labels") && visibility.labels === false ||
+        id.endsWith("Title") && visibility.titleStyle === false) visit(id, true);
+    }
+    for (const [direction, config] of Object.entries(program.guideConfigs.grid ?? {})) {
+      if (config.visible === false) visit({horizontal:"horizontalGridLines",vertical:"verticalGridLines",theta:"thetaGridLines",radius:"radialGridCircles",radial:"radialGridCircles"}[direction], true);
+    }
+  }
+  let next = changed ? program._clone({ graphicSpec: cloneAndFreeze({ ...program.graphicSpec, objects }) }) : program;
+  return restore || !Object.keys(backups).length
+    ? next._withoutMaterializationConfig(["guideVisibilityPaint"])
+    : next._withMaterializationConfig(["guideVisibilityPaint"], backups);
+}
+export function restoreGuideVisibilityPaint(program) { return paint(program, true); }
+export function applyGuideVisibilityPaint(program) { return paint(restoreGuideVisibilityPaint(program), false); }
+
+
+// Grids change paint/geometry inside the plot and do not need cross-guide reflow.
+export function withGuideVisibilityPaint(implementation) {
+  return function (args) {
+    if (this.context.deferGuideLayoutValidation === true) return implementation.call(this, args);
+    return applyGuideVisibilityPaint(implementation.call(restoreGuideVisibilityPaint(this), args));
+  };
+}

package/src/materialization/legendClip.js

@@ -14,7 +14,7 @@ function roles(kind,config){
   type:layer.type==='line'?'line':layer.type==='point'?config.channels.includes('shape')?'collection':'circle':hasRectRadius(layer)?'collection':'rect'
  }));
  const prefix=kind==='gradient'?'colorGradient':`${kind}Legend`;
- return [{id:`${prefix}Symbols`,type:'circle',point:true}];
+ return [{id:`${prefix}Symbols`,type:config.shapeScale===undefined?'circle':'collection',point:true}];
 }
 function wrapped(owner){return owner?.children?.some(id=>id.startsWith(clipPrefix));}
 export function hasLegendClipGraphics(program){

package/src/materialization/legendGroups.js

@@ -1 +1 @@
-import{localLegendPosition as c,localLegendPlacement as s}from"../grammar/legendGroups.js";import"../core/vocabulary.js";import{PLOT_LEGEND_POSITIONS as l}from"../layout/legend.js";function u(n,t){return n.guideConfigs.legendGroups?.[t]}function f(n,t){const e=s(t),o=e===void 0?u(n,t.target)??(n.context.facetLegendIntrinsic===!0?{placement:{position:t.position}}:void 0):{placement:e};if(o===void 0)return t;const i=o.placement.position,r=l.includes(i),p=r?t.direction==="horizontal"?"top":"right":i??(l.includes(t.position)?t.direction==="horizontal"?"top":"right":t.position??"right");return{...t,...e===void 0?{}:{blockLocalPosition:e.position},position:p,offset:0,align:"left",groupIntrinsic:!0,...r?{groupCorner:!0}:{},...p==="right"?{align:"center"}:{}}}export{f as intrinsicLegendConfig,u as legendGroup,s as localLegendPlacement,c as localLegendPosition};
+import{localLegendPosition as u,localLegendPlacement as d,retainsLegendSlot as c}from"../grammar/legendGroups.js";import"../core/vocabulary.js";import{PLOT_LEGEND_POSITIONS as l}from"../layout/legend.js";function p(e,t){return e.guideConfigs.legendGroups?.[t]}function m(e,t){const n=d(t);if(e.context.facetLegendIntrinsic!==!0&&p(e,t.target)===void 0&&n?.position===t.position&&t.inferredOffset!==!1&&["left","right","top","bottom"].includes(t.position))return t;const o=n===void 0?p(e,t.target)??(e.context.facetLegendIntrinsic===!0?{placement:{position:t.position}}:void 0):{placement:n};if(o===void 0)return t;const i=o.placement.position,r=l.includes(i),s=r?t.direction==="horizontal"?"top":"right":i??(l.includes(t.position)?t.direction==="horizontal"?"top":"right":t.position??"right");return{...t,...n===void 0?{}:{blockLocalPosition:n.position},position:s,offset:0,align:"left",groupIntrinsic:!0,...r?{groupCorner:!0}:{},...s==="right"?{align:"center"}:{}}}export{m as intrinsicLegendConfig,p as legendGroup,d as localLegendPlacement,u as localLegendPosition,c as retainsLegendSlot};

package/src/materialization/legendItemsOffset.js

@@ -0,0 +1,68 @@
+import { cloneAndFreeze } from "../core/immutable.js";
+import { legendResourcePolicies } from "./guides/resources.js";
+import { translatedProperties } from "./graphicTranslation.js";
+import { unionConcreteGraphicBounds } from "../grammar/schemas/graphicBounds.js";
+import { editLegendBorderBounds } from "./legendBorder.js";
+
+// Layout always works with the native, unshifted block. Retain its concrete
+// baseline so an unrelated transaction can restore it without regenerating
+// marks or accumulating translations. Rebuilt resources supersede old paint.
+export function restoreLegendItemsOffset(program) {
+  const retained = program.materializationConfigs.legendItemsPaint;
+  if (!retained) return program;
+  const objects = { ...program.graphicSpec.objects };
+  for (const [id, { before, after }] of Object.entries(retained)) {
+    if (objects[id] === after || JSON.stringify(objects[id]) === JSON.stringify(after)) objects[id] = before;
+  }
+  return program._clone({ graphicSpec: cloneAndFreeze({ ...program.graphicSpec, objects }) })
+    ._withoutMaterializationConfig(["legendItemsPaint"]);
+}
+
+export function applyLegendItemsOffset(program) {
+  let next = restoreLegendItemsOffset(program);
+  if (!Object.values(next.guideConfigs.legend ?? {}).some(config => config.itemsOffset?.x || config.itemsOffset?.y)) return next;
+  const baseline = next.graphicSpec.objects, objects = { ...baseline }, retained = {};
+  const touched = new Set();
+  function shift(id, dx, dy) {
+    const object = objects[id];
+    if (!object) return;
+    touched.add(id);
+    const moved = { ...object };
+    if (object.properties) moved.properties = translatedProperties(object.type, object.properties, dx, dy);
+    if (object.clip) moved.clip = { ...object.clip, x: object.clip.x + dx, y: object.clip.y + dy };
+    if (object.items) moved.items = object.items.map(item => ({ ...item,
+      properties: translatedProperties(item.type ?? object.type, item.properties, dx, dy) }));
+    objects[id] = moved;
+    // Canvas children inherit the translated clipping window.
+    if (object.type !== "canvas") for (const child of object.children ?? []) shift(child, dx, dy);
+  }
+  const changed = [];
+  for (const policy of legendResourcePolicies()) {
+    const config = next.guideConfigs.legend?.[policy.kind];
+    const { x = 0, y = 0 } = config?.itemsOffset ?? {};
+    if (!x && !y) continue;
+    const body = policy.graphicIds.filter(id => !/(Title|Background)$/.test(id));
+    for (const id of body) shift(id, x, y);
+    changed.push({ policy, config });
+  }
+  if (!changed.length) return next;
+  next = next._clone({ graphicSpec: cloneAndFreeze({ ...next.graphicSpec, objects }) });
+  for (const { policy, config } of changed) {
+    const background = policy.graphicIds.find(id => id.endsWith("Background"));
+    if (!next.graphicSpec.objects[background]) continue;
+    touched.add(background);
+    const bounds = unionConcreteGraphicBounds(next.graphicSpec,
+      policy.graphicIds.filter(id => id !== background && next.graphicSpec.objects[id]), next.materializationConfigs.textMetrics);
+    if (!bounds) continue;
+    const padding = config.border?.padding ?? 0;
+    next = editLegendBorderBounds(next, background, { x: bounds.left - padding, y: bounds.top - padding,
+      width: bounds.right - bounds.left + padding * 2, height: bounds.bottom - bounds.top + padding * 2 });
+  }
+  for (const id of touched) {
+    const object = next.graphicSpec.objects[id];
+    if (baseline[id] && object !== baseline[id]) {
+      retained[id] = { before: baseline[id], after: object };
+    }
+  }
+  return next._withMaterializationConfig(["legendItemsPaint"], retained);
+}

package/src/materialization/legendSuppression.js

@@ -0,0 +1,22 @@
+import { legendBlockChannels } from "../grammar/legendBlocks.js";
+
+// Replayable authoring intent, independent of the current concrete legend blocks.
+export function suppressLegendChannels(program, target, channels) {
+  const previous = program.guideConfigs.suppressedLegends?.[target]?.channels ?? [];
+  return program._withMaterializationConfig(["guides", "suppressedLegends", target],
+    { channels: [...new Set([...previous, ...channels])] });
+}
+
+export function restoreCreatedLegendChannels(program) {
+  let next = program;
+  for (const [target, { channels: suppressed }] of Object.entries(program.guideConfigs.suppressedLegends ?? {})) {
+    const active = new Set(Object.entries(program.guideConfigs.legend ?? {})
+      .filter(([, config]) => config.target === target)
+      .flatMap(([kind, config]) => legendBlockChannels(kind, config)));
+    const remaining = suppressed.filter(channel => !active.has(channel));
+    if (remaining.length === suppressed.length) continue;
+    next = remaining.length ? next._withMaterializationConfig(["guides", "suppressedLegends", target], { channels: remaining })
+      : next._withoutMaterializationConfig(["guides", "suppressedLegends", target]);
+  }
+  return next;
+}

package/src/materialization/legends.js

@@ -1,8 +1,9 @@
+import {colorSizeScaleIds} from "../grammar/colorSizeLegend.js";
 import { findLayer } from "../selectors/layers.js";
 import { LEGEND_CONFIG_KINDS } from "../core/vocabulary.js";
 
 export function isOpacityLegendLayer(layer) {
-  return ["point", "line", "bar", "rect"].includes(layer.mark?.type) &&
+  return ["point", "line", "area", "bar", "rect"].includes(layer.mark?.type) &&
     layer.encoding?.opacity?.scale !== undefined;
 }
 
@@ -24,6 +25,6 @@ export function materializedLegendUsesScale(program, id) {
     const order = program.semanticSpec.guides.legend?.[kind]?.order;
     const linkedScale = order?.channel === undefined ? undefined
       : findLayer(program, config.target)?.encoding?.[order.channel]?.scale;
-    return config.colorScale === id || config.sizeScale === id || config.scale === id || config.scales?.includes(id) || linkedScale === id;
+    return (kind === "colorSize" ? colorSizeScaleIds(config).includes(id) : config.scale === id || config.scales?.includes(id)) || linkedScale === id;
   });
 }

package/src/materialization/marks/capabilities.js

@@ -1,3 +1,4 @@
+import { isHorizontalLine } from "../../grammar/lineSeries.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { findLayer } from "../../selectors/layers.js";
 import { findCoordinate } from "../../selectors/coordinates.js";
@@ -37,6 +38,7 @@ export function canMaterializeTick(_program, layer) {
 }
 
 export function canMaterializeLine(program, layer) {
+  if (layer.derivedBindings?.overlay) return hasCartesianPositionScales(layer);
   const parallel = layer.encoding?.parallel;
   if (parallel !== undefined) {
     const coordinate = findCoordinate(program, layer.coordinate);
@@ -45,6 +47,8 @@ export function canMaterializeLine(program, layer) {
       parallel.dimensions?.length >= 2 &&
       parallel.dimensions.every(dimension => dimension.scale !== undefined);
   }
+  if (isHorizontalLine(layer)) return canMaterializeLine(program, { ...layer,
+    encoding: { ...layer.encoding, x: layer.encoding.y, y: layer.encoding.x } });
   const dataset = findDataset(program, layer.data);
   const interval = dataset?.transform?.some(item => item.type === "interval");
   if (hasPolarPositionScales(layer)) {

package/src/materialization/marks/index.js

@@ -36,6 +36,7 @@ export function getScaleConsumerMarkSteps(program, scaleIds) {
 }
 
 export function getMarkRematerializationStep(program, layer) {
+  if (layer.derivedBindings?.overlay) return { op: "rematerializeOverlay", args: { id: layer.id } };
   if (program.markConfigs?.[layer.id]?.statisticalReference !== undefined) {
     return { op: "rematerializeStatisticalReference", args: { id: layer.id } };
   }
@@ -63,7 +64,8 @@ export function getSourceDependentMarkSteps(program, sourceId) {
     const statistical = program.markConfigs?.[layer.id]
       ?.statisticalReference?.source === sourceId;
     const filteredCompanion = program.markConfigs?.[layer.id]?.markFilter?.owner === sourceId;
-    return sourceOwned || statistical || filteredCompanion
+    const overlay = layer.derivedBindings?.overlay?.source === sourceId;
+    return sourceOwned || statistical || filteredCompanion || overlay
       ? [getMarkMaterializationStep(program, layer) ??
           getExistingMarkRematerializationStep(program, layer)].filter(
           step => step !== undefined
@@ -104,6 +106,7 @@ export function getPositionEncodingMaterializationSteps(program, layer, scaleId)
 }
 
 export function getScaleConsumerMaterializationMode(layer, channel) {
+  if (layer.derivedBindings?.overlay) return "defer";
   const policy = getMarkMaterializationPolicy(layer);
   if (policy === undefined) return "direct";
   if (POSITION_ENCODING_CHANNELS.includes(channel)) {
@@ -118,6 +121,7 @@ export function getScaleConsumerMaterializationMode(layer, channel) {
 }
 
 export function canDeferScaleConsumerApplication(layer) {
+  if (layer.derivedBindings?.overlay) return true;
   return getMarkMaterializationPolicy(layer)?.scaleApplication.deferWithMark === true;
 }
 

package/src/materialization/marks/pathOrder.js

@@ -56,7 +56,7 @@ export function pathOrderCompatibility(program, layer) {
       reason: "does not support generated error or regression paths"
     };
   }
-  if (layer.mark.type === "line" && isAggregate(layer.encoding?.y?.aggregate)) {
+  if (layer.mark.type === "line" && (isAggregate(layer.encoding?.y?.aggregate) || isAggregate(layer.encoding?.x?.aggregate))) {
     return { compatible: false, reason: "does not support aggregate lines" };
   }
   return { compatible: true, dataset };

package/src/materialization/marks/policies.js

@@ -51,7 +51,8 @@ const MARK_MATERIALIZATION_POLICIES = Object.freeze({
     acceptsResolvedScales: true,
     positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: true }),
     encoding: Object.freeze({
-      sharedChannels: Object.freeze(["color", "stroke"]),
+      completeOnly: true,
+      sharedChannels: Object.freeze(["color", "stroke", "opacity"]),
       skipRematerialization: isIntentionallyEmptyArea
     }),
     scaleApplication: Object.freeze({ default: "defer" })

package/src/materialization/overlayItems.js

@@ -0,0 +1,154 @@
+import { findCoordinate } from "../selectors/coordinates.js";
+import { requireLayer } from "../selectors/layers.js";
+import { requireMaterializedDataset } from "../selectors/datasets.js";
+import { resolveBarItems, resolveBarItemDefinitions } from "./selection/items/bar.js";
+import { resolvePointItems } from "./selection/items/point.js";
+import { applyItemMissingPolicy } from "../grammar/itemMissing.js";
+import { resolveBarChannels, resolveBarColorLayout } from "../grammar/bars/policy.js";
+import { overlayGroupFields, overlayPositionEncoding, overlaySourceReason } from "../grammar/overlay.js";
+import { mapContinuousScaleValues, mapOrdinalPositionValues } from "../grammar/scales/index.js";
+import { deriveLineSeries, resolveLineBins } from "../grammar/lineSeries.js";
+import { deriveAreaSeries, deriveCenteredAreaSeries, deriveDensityAreaSeries, layoutDensityAreaSeries } from "../grammar/areaSeries.js";
+import { findUpstreamTransform } from "./dataProvenance.js";
+import { requireSemanticScale } from "../selectors/scales.js";
+import { uniqueFields, ownFields, channelMapFromRow } from "./selection/items/common.js";
+import { pointGraphicAnchor } from "../grammar/pointShapes.js";
+import { mapScaleConsumerValues } from "./scales/map.js";
+import { resolveDirectionValues } from "../grammar/direction.js";
+
+export function overlaySegments(group, binding) {
+  const segments = [[]];
+  for (const point of group.points) {
+    const before = segments.at(-1).at(-1);
+    if (binding.missing === "break" && ((before?.bin && point.bin &&
+        Math.abs(before.bin[1] - point.bin[0]) > 1e-10) ||
+        (Number.isFinite(before?.categoryIndex) && Number.isFinite(point.categoryIndex) &&
+          Math.abs(point.categoryIndex - before.categoryIndex) > 1))) segments.push([]);
+    segments.at(-1).push(point);
+  }
+  return segments.filter(points => points.length);
+}
+
+function sourcePointAnchor(program, source, item, graphics) {
+  const owner = program.graphicSpec.objects[source.id];
+  const graphic = graphics.get(item.graphicIds[0]);
+  const encoding = source.encoding.shape;
+  const shape = encoding?.scale ? mapScaleConsumerValues([item.fields[encoding.field]], program.resolvedScales[encoding.scale], "shape")[0]
+    : program.markConfigs[source.id].shape ?? "circle";
+  const angle = resolveDirectionValues(item.members, source.encoding.angle)?.[0];
+  return pointGraphicAnchor({ ...graphic, type: graphic.type ?? owner.type }, shape, angle);
+}
+
+function mapPosition(program, source, channel, value) {
+  const encoding = source.encoding[channel];
+  const scale = program.resolvedScales[encoding.scale];
+  const map = ["nominal", "ordinal"].includes(encoding.fieldType)
+    ? mapOrdinalPositionValues : mapContinuousScaleValues;
+  return map([value], scale)[0];
+}
+
+function itemGroups(items, source, binding) {
+  const fields = overlayGroupFields(source);
+  const groups = new Map();
+  for (const item of items) {
+    const tuple = fields.map(field => item.fields[field] ?? item.members[0]?.[field]);
+    const key = binding.series === "total" ? "total" : JSON.stringify(tuple);
+    if (!groups.has(key)) groups.set(key, { key, members: [], points: [] });
+    const group = groups.get(key);
+    group.members.push(...item.members);
+    group.points.push(item);
+  }
+  return [...groups.values()];
+}
+
+export function resolveOverlaySeries(program, binding, { geometry = true } = {}) {
+  const source = requireLayer(program, binding.source);
+  const dataset = applyItemMissingPolicy(source, requireMaterializedDataset(program, source.data));
+  const density = findUpstreamTransform(program, dataset, 'density');
+  const unsupported = overlaySourceReason(source, findCoordinate(program, source.coordinate)?.type, density);
+  if (unsupported) throw new Error(unsupported);
+  if (["bar", "point"].includes(source.mark.type)) {
+    const bar = source.mark.type === "bar";
+    if (!bar && !binding.orderBy) throw new Error("Connecting point results requires explicit orderBy x or y.");
+    const channels = bar ? resolveBarChannels(source) : { category: binding.orderBy, measure: binding.orderBy === "y" ? "x" : "y" };
+    // Scale domains need the new final item grain before source graphics have
+    // been rebuilt (for example, after facet filtering). Geometry consumers
+    // still resolve and validate the fully materialized source collections.
+    const items = geometry
+      ? bar ? resolveBarItems(program, source, dataset, "item") : resolvePointItems(program, source, dataset)
+      : bar ? resolveBarItemDefinitions(program, source, dataset)
+        : dataset.values.map(row => ({ fields: ownFields(row), channels: channelMapFromRow(row, source), members: [row] }));
+    const graphics = bar || !geometry ? undefined : new Map(program.graphicSpec.objects[source.id].items.map(item => [item.id, item]));
+    const anchors = items.map(item => {
+      const p = item.properties;
+      const measure = item.channels[`${channels.measure}2`] ?? item.channels[channels.measure];
+      const point = !geometry ? item.channels : bar ? p : sourcePointAnchor(program, source, item, graphics);
+      const endpoint = bar && geometry ? mapPosition(program, source, channels.measure, measure) : point[channels.measure];
+      const x = geometry && bar && channels.category === "x" ? p.x + p.width / 2 : channels.measure === "x" ? endpoint : point.x;
+      const y = geometry && bar && channels.category === "y" ? p.y + p.height / 2 : channels.measure === "y" ? endpoint : point.y;
+      const category = item.channels[channels.category];
+      const categoryEnd = item.channels[`${channels.category}2`];
+      const categoryScale = program.resolvedScales[source.encoding[channels.category].scale];
+      const categoryValue = bar && source.encoding[channels.category].bin ? (category + categoryEnd) / 2 : category;
+      return { ...item, x, y, measure, category,
+        fields: { ...item.fields, ...(bar ? { [source.encoding[channels.measure].field]: measure,
+          [source.encoding[channels.category].field]: categoryValue } : {}) },
+        channels: { ...item.channels, ...(bar ? { [channels.measure]: measure, [channels.category]: categoryValue } : {}) },
+        ...(["point", "band", "ordinal"].includes(categoryScale.type) ? { categoryIndex: categoryScale.domain.indexOf(category) } : {}),
+        ...(bar && channels.category === "x" && source.encoding.x.bin ? { bin: [category, categoryEnd] } : {}) };
+    }).filter(item => !geometry || Number.isFinite(item.x) && Number.isFinite(item.y));
+    let groups = itemGroups(anchors, source, binding);
+    if (bar && binding.series === "total") {
+      if (overlayGroupFields(source).length && !["stack", "fill", "diverging"].includes(resolveBarColorLayout(source))) {
+        throw new Error("A total overlay requires stacked source series; grouped and overlapping bars have separate endpoints.");
+      }
+      const cells = new Map();
+      for (const item of anchors) {
+        const key = JSON.stringify([item.category, item.bin, item.measure < 0 ? "negative" : "positive"]);
+        const previous = cells.get(key);
+        if (!previous || Math.abs(item.measure) > Math.abs(previous.measure)) cells.set(key, item);
+      }
+      groups = [false, true].map(negative => ({ key: negative ? "negative-total" : "positive-total",
+        points: [...cells.values()].filter(item => (item.measure < 0) === negative), members: anchors.flatMap(item => item.members) }))
+        .filter(group => group.points.length);
+    }
+    const direction = binding.orderBy ?? channels.category;
+    for (const group of groups) {
+      // Y categories run upward in data space. Preserve the source scale's order.
+      const sign = direction === "y" ? -1 : 1;
+      group.points.sort((a, b) => sign * (a[direction] - b[direction]));
+    }
+    return groups;
+  }
+  const x = source.encoding.x;
+  const derived = source.mark.type === "line"
+    ? deriveLineSeries(dataset.values, source, { scales: program.semanticSpec.scales,
+      xDomain: program.resolvedScales[x.scale]?.domain,
+      yDomain: program.resolvedScales[source.encoding.y.scale]?.domain,
+      ...(x.bin ? { xBinBoundaries: resolveLineBins(dataset.values, source, requireSemanticScale(program, x.scale)).boundaries } : {}) })
+    : density ? layoutDensityAreaSeries(deriveDensityAreaSeries(dataset.values, source, density), source.layout?.mode ?? source.encoding.color?.layout ?? "overlay")
+      : source.encoding.y?.stack === "center" ? deriveCenteredAreaSeries(dataset.values, source)
+        : deriveAreaSeries(dataset.values, source, { xDomain: program.resolvedScales[x.scale]?.domain,
+          yDomain: program.resolvedScales[source.encoding.y.scale]?.domain });
+  if (binding.series === "total" && derived.series.length > 1) {
+    throw new Error("Total overlays currently require stacked bars; use source series for line or area results.");
+  }
+  function endpoint(point, channel) {
+    if (channel === "y" && point.upper !== undefined) return point.upper;
+    if (source.mark.type === "area" && (source.layout?.mode ?? "overlay") === "overlay" &&
+      Object.hasOwn(source.encoding[`${channel}2`] ?? {}, "datum")) return point[channel];
+    return point[`${channel}2`] ?? point[channel];
+  }
+  return derived.series.map((series, index) => {
+    const members = series.sourceIndices ? series.sourceIndices.map(i => dataset.values[i])
+      : dataset.values.filter(row => Object.entries(series.key).every(([field, value]) => row[field] === value));
+    return { key: JSON.stringify([series.key, index]), members,
+      points: series.values.map((point, i) => ({ key: JSON.stringify([series.key, i]), members,
+        fields: { ...uniqueFields(members), ...series.key,
+          [overlayPositionEncoding(source, "x").field]: endpoint(point, "x"),
+          [overlayPositionEncoding(source, "y").field]: endpoint(point, "y") },
+        x: mapPosition(program, source, "x", endpoint(point, "x")),
+        y: mapPosition(program, source, "y", endpoint(point, "y")),
+        channels: { x: endpoint(point, "x"), y: endpoint(point, "y") } })) };
+  });
+}

package/src/materialization/scales/policies/binnedPosition.js

@@ -1,8 +1,10 @@
 import { isSourceOwnedText } from "../../../grammar/text.js";
-import { resolveHistogramBins } from "../../../grammar/histogram.js";
+import { compositionChannel } from "../../../selectors/plotComposition.js";
+import { findHistogramBinIndex, resolveHistogramBins } from "../../../grammar/histogram.js";
 
 export function resolveBinnedPositionDomain({
   valuesByConsumer,
+  program,
   channel,
   scale,
   id
@@ -14,9 +16,21 @@ export function resolveBinnedPositionDomain({
   );
   if (binnedPositions.length === 0) return undefined;
   const independentConsumers = valuesByConsumer.filter(({ consumer, scalePolicy }) =>
-    scalePolicy !== false && !isSourceOwnedText(consumer.layer)
+    scalePolicy !== false && !isSourceOwnedText(consumer.layer) && consumer.layer.mark?.type !== "tick"
   );
-  if (channel !== "x" || binnedPositions.length !== independentConsumers.length) {
+  const signature = consumer => {
+    const role = program && compositionChannel(program, consumer.encoding, consumer.layer.data);
+    return role && role.fieldType === "quantitative" ? JSON.stringify([
+      role.field ?? null, role.fields ?? null, role.measurement.unit, role.temporalUnit ?? null
+    ]) : undefined;
+  };
+  const expected = signature(binnedPositions[0].consumer);
+  // Binning changes sampling, not the physical value units of a position.
+  // Raw points and compatible summary paths can share that coordinate while
+  // retaining their own observations and the binned mark's original bins.
+  const compatibleUnbinned = expected !== undefined && independentConsumers.every(({ consumer }) =>
+    signature(consumer) === expected);
+  if (channel !== "x" || (binnedPositions.length !== independentConsumers.length && !compatibleUnbinned)) {
     throw new Error(
       `Binned scale "${id}" cannot be shared with an unbinned consumer.`
     );
@@ -27,11 +41,35 @@ export function resolveBinnedPositionDomain({
   if (binDefinitions.size !== 1) {
     throw new Error(`Binned scale "${id}" requires one shared bin definition.`);
   }
-  return resolveHistogramBins({
+  const bins = resolveHistogramBins({
     values: binnedPositions.flatMap(item => item.values).filter(value => value !== undefined),
     bin: binnedPositions[0].consumer.encoding.bin,
     domain: scale.domain,
     nice: scale.nice ?? true,
     zero: scale.zero ?? false
-  }).domain;
+  });
+  if (Array.isArray(scale.domain)) return bins.domain;
+  let [minimum, maximum] = bins.domain;
+  // A final-item filter freezes the bin partition so surviving observations
+  // are never rebinned. Those boundaries describe the partition, not a fixed
+  // display domain: auto scales follow the retained bins' complete intervals.
+  // An unfiltered consumer still contributes its full requested bin extent.
+  if (binnedPositions.every(({ consumer }) => program?.markConfigs[consumer.layer.id]?.markFilter)) {
+    let first = Infinity, last = -1;
+    for (const { values } of binnedPositions) for (const value of values) {
+      if (!Number.isFinite(value)) continue;
+      const index = findHistogramBinIndex(value, bins.boundaries);
+      if (index < 0) continue;
+      first = Math.min(first, index); last = Math.max(last, index);
+    }
+    if (last >= 0) {
+      minimum = bins.boundaries[first]; maximum = bins.boundaries[last + 1];
+      if (scale.zero) { minimum = Math.min(0, minimum); maximum = Math.max(0, maximum); }
+    }
+  }
+  for (const { values } of independentConsumers) for (const value of values) {
+    if (!Number.isFinite(value)) continue;
+    minimum = Math.min(minimum, value); maximum = Math.max(maximum, value);
+  }
+  return [minimum, maximum];
 }

package/src/materialization/scales/policies/series.js

@@ -5,8 +5,10 @@ import {
   resolveTransformedDomain
 } from "../../../grammar/scales/index.js";
 import { numericExtent } from "../../../grammar/numeric.js";
+import { compositionChannel } from "../../../selectors/plotComposition.js";
 
 export function resolveSeriesLayoutDomain({
+  program,
   id,
   scale,
   valuesByConsumer,
@@ -15,7 +17,9 @@ export function resolveSeriesLayoutDomain({
   if (!seriesLayouts.some(Boolean)) return undefined;
   const activeLayouts = seriesLayouts.filter(Boolean);
   const layouts = new Set(activeLayouts.map(item => item.layout));
-  if (layouts.size !== 1) {
+  // Independent native layers may use different layouts in the same value
+  // units. Only normalized/centered policies change the axis interpretation.
+  if (layouts.size !== 1 && [...layouts].some(layout => !["group", "overlay", "stack", "diverging"].includes(layout))) {
     throw new Error(`Series layout scale "${id}" requires one layout policy.`);
   }
   const layoutConsumers = valuesByConsumer.filter(
@@ -36,8 +40,12 @@ export function resolveSeriesLayoutDomain({
         layout === "overlay" ||
         Object.hasOwn(directEncoding, "datum") ||
         (
-          aggregate !== "count" &&
-          directEncoding.field === layoutConsumer.encoding.field
+            (directEncoding.field === layoutConsumer.encoding.field || program &&
+              compositionChannel(program, directEncoding, consumer.layer.data)?.field ===
+                compositionChannel(program, layoutConsumer.encoding, layoutConsumer.layer.data)?.field) && (
+            aggregate !== "count" || (directEncoding.aggregate === "count" &&
+              JSON.stringify(consumer.layer.encoding.x?.bin) === JSON.stringify(layoutConsumer.layer.encoding.x?.bin))
+          )
         )
       );
     })
@@ -61,7 +69,7 @@ export function resolveSeriesLayoutDomain({
     }
   }
   if (
-    ["group", "overlay"].includes(layout) &&
+    [...layouts].some(item => ["group", "overlay"].includes(item)) &&
     scale.domain !== "auto" &&
     (numericExtent(scale.domain)[0] > 0 || numericExtent(scale.domain)[1] < 0)
   ) {

package/src/materialization/scales/resolve.js

@@ -325,6 +325,7 @@ export function resolveScaleMaterialization(options) {
   const binnedDomain = isDiscretizedColor
     ? undefined
     : resolveBinnedPositionDomain({
+        program: options.program,
         valuesByConsumer,
         channel,
         scale,
@@ -334,6 +335,7 @@ export function resolveScaleMaterialization(options) {
   const seriesDomain = isDiscretizedColor || binnedDomain !== undefined
     ? undefined
     : resolveSeriesLayoutDomain({
+        program: options.program,
         id,
         scale,
         valuesByConsumer,