ggaction 0.0.23 → 0.0.26

package/src/grammar/parallelCoordinates.js

@@ -1,208 +1 @@
-import { requireStringValue as nonEmptyString } from "../core/validation.js";
-import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
-import { validateUserId } from "../core/identifiers.js";
-import { validateOptionObject } from "../core/validation.js";
-import {
-  mapContinuousScaleValues,
-  mapOrdinalPositionValues,
-  validateSemanticFieldType
-} from "./scales/index.js";
-
-const DIMENSION_OPTIONS = Object.freeze([
-  "field", "fieldType", "title", "scale"
-]);
-const FIELD_TYPES = new Set(["quantitative", "ordinal"]);
-const MISSING_POLICIES = new Set(["break", "drop-row", "error"]);
-const DIMENSION_SCALE_OPTIONS = Object.freeze([
-  "type", "domain", "range", "nice", "zero", "clamp", "reverse",
-  "base", "exponent", "constant", "paddingInner", "paddingOuter",
-  "padding", "align", "unknown"
-]);
-
-
-export function validateParallelKeyField(value) {
-  return nonEmptyString(value, "Parallel key field");
-}
-
-function inferFieldType(rows, field) {
-  const values = rows
-    .map(row => row[field])
-    .filter(value => value !== undefined && value !== null);
-  if (values.length === 0) {
-    throw new Error(`Cannot infer Parallel field type for "${field}".`);
-  }
-  if (values.every(Number.isFinite)) return "quantitative";
-  if (values.every(value => typeof value === "string")) return "ordinal";
-  throw new Error(
-    `Parallel dimension "${field}" requires an explicit compatible fieldType.`
-  );
-}
-
-function validateScaleOptions(value, index) {
-  if (value === undefined) return {};
-  if (!isPlainObject(value)) {
-    throw new TypeError(`Parallel dimension ${index} scale must be a plain object.`);
-  }
-  validateOptionObject(
-    value,
-    DIMENSION_SCALE_OPTIONS,
-    `Parallel dimension ${index} scale`
-  );
-  return { ...value };
-}
-
-export function validateParallelMissingPolicy(value) {
-  if (!MISSING_POLICIES.has(value)) {
-    throw new Error(`Unsupported Parallel missing policy "${value}".`);
-  }
-  return value;
-}
-
-export function validateParallelDimensions(dimensions, { normalized = false } = {}) {
-  if (!Array.isArray(dimensions) || dimensions.length < 2) {
-    throw new RangeError("Parallel coordinates require at least two dimensions.");
-  }
-  const fields = new Set();
-  for (const [index, dimension] of dimensions.entries()) {
-    if (!isPlainObject(dimension)) {
-      throw new TypeError(`Parallel dimension ${index} must be an object.`);
-    }
-    const supported = normalized
-      ? ["field", "fieldType", "title", "scale"]
-      : DIMENSION_OPTIONS;
-    validateOptionObject(dimension, supported, `Parallel dimension ${index}`);
-    const field = nonEmptyString(
-      dimension.field,
-      `Parallel dimension ${index} field`
-    );
-    if (fields.has(field)) {
-      throw new Error("Parallel dimensions must use unique fields.");
-    }
-    fields.add(field);
-    validateSemanticFieldType(dimension.fieldType);
-    if (!FIELD_TYPES.has(dimension.fieldType)) {
-      throw new Error(`Unsupported Parallel field type "${dimension.fieldType}".`);
-    }
-    nonEmptyString(dimension.title, `Parallel dimension ${index} title`);
-    validateUserId(dimension.scale, `Parallel dimension ${index} scale id`);
-  }
-  return dimensions;
-}
-
-export function normalizeParallelDimensions(rows, dimensions, target) {
-  if (!Array.isArray(dimensions) || dimensions.length < 2) {
-    throw new RangeError("Parallel coordinates require at least two dimensions.");
-  }
-  const normalized = dimensions.map((input, index) => {
-    const dimension = typeof input === "string" ? { field: input } : input;
-    if (!isPlainObject(dimension)) {
-      throw new TypeError(
-        `Parallel dimension ${index} must be a field string or plain object.`
-      );
-    }
-    validateOptionObject(
-      dimension,
-      DIMENSION_OPTIONS,
-      `Parallel dimension ${index}`
-    );
-    const field = nonEmptyString(
-      dimension.field,
-      `Parallel dimension ${index} field`
-    );
-    const fieldType = dimension.fieldType ?? inferFieldType(rows, field);
-    if (!FIELD_TYPES.has(fieldType)) {
-      throw new Error(`Unsupported Parallel field type "${fieldType}".`);
-    }
-    const scale = validateScaleOptions(dimension.scale, index);
-    return {
-      field,
-      fieldType,
-      title: dimension.title ?? field,
-      scale: `${target}-parallel-${index}`,
-      scaleOptions: scale
-    };
-  });
-  const fields = normalized.map(dimension => dimension.field);
-  if (new Set(fields).size !== fields.length) {
-    throw new Error("Parallel dimensions must use unique fields.");
-  }
-  return cloneAndFreeze(normalized);
-}
-
-function validDimensionValue(value, fieldType) {
-  return fieldType === "quantitative"
-    ? Number.isFinite(value)
-    : typeof value === "string" || Number.isFinite(value);
-}
-
-function commandsFromVertices(vertices) {
-  const commands = [];
-  let fragment = [];
-  const flush = () => {
-    if (fragment.length >= 2) {
-      fragment.forEach((point, index) => commands.push({
-        op: index === 0 ? "M" : "L",
-        x: point.x,
-        y: point.y
-      }));
-    }
-    fragment = [];
-  };
-  for (const vertex of vertices) {
-    if (vertex === undefined) flush();
-    else fragment.push(vertex);
-  }
-  flush();
-  return commands;
-}
-
-export function validateParallelRows(rows, dimensions, { key, missing }) {
-  const seen = new Set();
-  rows.forEach((row, index) => {
-    if (key !== undefined) {
-      const value = row[key];
-      if (value === undefined || value === null || value === "") {
-        throw new Error(`Parallel key is missing at row ${index}.`);
-      }
-      const token = `${typeof value}:${String(value)}`;
-      if (seen.has(token)) throw new Error(`Duplicate Parallel key "${value}".`);
-      seen.add(token);
-    }
-    const incomplete = dimensions.some(dimension =>
-      !validDimensionValue(row[dimension.field], dimension.fieldType)
-    );
-    if (incomplete && missing === "error") {
-      throw new Error(`Parallel row ${index} has a missing dimension.`);
-    }
-  });
-}
-
-export function materializeParallelRows(rows, dimensions, resolvedScales, bounds, {
-  key,
-  missing
-}) {
-  validateParallelRows(rows, dimensions, { key, missing });
-  const step = bounds.width / (dimensions.length - 1);
-  const items = [];
-  rows.forEach((row, sourceRowIndex) => {
-    const vertices = dimensions.map((dimension, index) => {
-      const value = row[dimension.field];
-      if (!validDimensionValue(value, dimension.fieldType)) return undefined;
-      const scale = resolvedScales[dimension.scale];
-      const mapped = dimension.fieldType === "quantitative"
-        ? mapContinuousScaleValues([value], scale)[0]
-        : mapOrdinalPositionValues([value], scale)[0];
-      return Number.isFinite(mapped)
-        ? { x: bounds.x + step * index, y: mapped, value, dimension: dimension.field }
-        : undefined;
-    });
-    const incomplete = vertices.some(vertex => vertex === undefined);
-    if (incomplete && missing === "drop-row") return;
-    items.push({
-      key: key === undefined ? `source:${sourceRowIndex}` : row[key],
-      sourceRowIndex,
-      commands: commandsFromVertices(vertices)
-    });
-  });
-  return cloneAndFreeze(items);
-}
+import{requireStringValue as P}from"../core/validation.js";import{cloneAndFreeze as N,isOwned as E,isPlainObject as $}from"../core/immutable.js";import{validateUserId as I}from"../core/identifiers.js";import{validateOptionObject as S}from"../core/validation.js";import{mapContinuousScaleValues as A,mapOrdinalPositionValues as D,validateSemanticFieldType as M}from"./scales/index.js";const q=Object.freeze(["field","fieldType","title","scale"]),F=new Set(["quantitative","ordinal"]),k=new Set(["break","drop-row","error"]),z=new WeakMap,x=Object.freeze(["id","type","domain","range","nice","zero","clamp","reverse","base","exponent","constant","paddingInner","paddingOuter","padding","align","unknown"]);function W(e){return P(e,"Parallel key field")}function V(e,t){const i=e.map(n=>n[t]).filter(n=>n!=null);if(i.length===0)throw new Error(`Cannot infer Parallel field type for "${t}".`);if(i.every(Number.isFinite))return"quantitative";if(i.every(n=>typeof n=="string"))return"ordinal";throw new Error(`Parallel dimension "${t}" requires an explicit compatible fieldType.`)}function _(e,t){if(e===void 0)return{};if(!$(e))throw new TypeError(`Parallel dimension ${t} scale must be a plain object.`);return S(e,x,`Parallel dimension ${t} scale`),{...e}}function Y(e){if(!k.has(e))throw new Error(`Unsupported Parallel missing policy "${e}".`);return e}function B(e,{normalized:t=!1}={}){if(!Array.isArray(e)||e.length<2)throw new RangeError("Parallel coordinates require at least two dimensions.");const i=new Set;for(const[n,r]of e.entries()){if(!$(r))throw new TypeError(`Parallel dimension ${n} must be an object.`);S(r,t?["field","fieldType","title","scale"]:q,`Parallel dimension ${n}`);const o=P(r.field,`Parallel dimension ${n} field`);if(i.has(o))throw new Error("Parallel dimensions must use unique fields.");if(i.add(o),M(r.fieldType),!F.has(r.fieldType))throw new Error(`Unsupported Parallel field type "${r.fieldType}".`);P(r.title,`Parallel dimension ${n} title`),I(r.scale,`Parallel dimension ${n} scale id`)}return e}function H(e,t,i){if(!Array.isArray(t)||t.length<2)throw new RangeError("Parallel coordinates require at least two dimensions.");const n=t.map((s,o)=>{const f=typeof s=="string"?{field:s}:s;if(!$(f))throw new TypeError(`Parallel dimension ${o} must be a field string or plain object.`);S(f,q,`Parallel dimension ${o}`);const l=P(f.field,`Parallel dimension ${o} field`),a=f.fieldType??V(e,l);if(!F.has(a))throw new Error(`Unsupported Parallel field type "${a}".`);const y=_(f.scale,o);return{field:l,fieldType:a,title:f.title??l,scale:y.id===void 0?`${i}-parallel-${o}`:I(y.id,"Parallel dimension scale id"),scaleOptions:y}}),r=n.map(s=>s.field);if(new Set(r).size!==r.length)throw new Error("Parallel dimensions must use unique fields.");return N(n)}function T(e,t){return t==="quantitative"?Number.isFinite(e):typeof e=="string"||Number.isFinite(e)}function C(e){const t=[];let i=[];const n=()=>{i.length>=2&&i.forEach((r,s)=>t.push({op:s===0?"M":"L",x:r.x,y:r.y})),i=[]};for(const r of e)r===void 0?n():i.push(r);return n(),t}function L(e,t,{key:i,missing:n}){const r=new Set;e.forEach((s,o)=>{if(i!==void 0){const l=s[i];if(l==null||l==="")throw new Error(`Parallel key is missing at row ${o}.`);const a=`${typeof l}:${String(l)}`;if(r.has(a))throw new Error(`Duplicate Parallel key "${l}".`);r.add(a)}if(t.some(l=>!T(s[l.field],l.fieldType))&&n==="error")throw new Error(`Parallel row ${o} has a missing dimension.`)})}function Q(e,t,i,n,{key:r,missing:s}){const o=t.map(c=>i[c.scale]),f=E(e)&&E(t)&&o.every(E),l=f?JSON.stringify({dimensions:t,scales:o,bounds:n,key:r,missing:s}):void 0;let a=f?z.get(e):void 0;if(a?.has(l)){const c=a.get(l);return a.delete(l),a.set(l,c),c}L(e,t,{key:r,missing:s});const y=n.width/(t.length-1),j=t.map((c,u)=>{const d=[],g=[];e.forEach((m,h)=>{const b=m[c.field];T(b,c.fieldType)&&(d.push(b),g.push(h))});const p=d.length===0?[]:c.fieldType==="quantitative"?A(d,o[u]):D(d,o[u]),w=new Array(e.length);return g.forEach((m,h)=>{w[m]=p[h]}),w}),O=[];e.forEach((c,u)=>{const d=t.map((p,w)=>{const m=c[p.field];if(!T(m,p.fieldType))return;const h=j[w][u];return Number.isFinite(h)?{x:n.x+y*w,y:h,value:m,dimension:p.field}:void 0});d.some(p=>p===void 0)&&s==="drop-row"||O.push({key:r===void 0?`source:${u}`:c[r],sourceRowIndex:u,commands:C(d)})});const v=N(O);return f&&(a||z.set(e,a=new Map),a.set(l,v),a.size>4&&a.delete(a.keys().next().value)),v}export{Q as materializeParallelRows,H as normalizeParallelDimensions,B as validateParallelDimensions,W as validateParallelKeyField,Y as validateParallelMissingPolicy,L as validateParallelRows};

package/src/grammar/pathCommands.js

@@ -1,4 +1,4 @@
-import { freezeOwned, isPlainObject } from "../core/immutable.js";
+import { freezeOwned, isOwned, isPlainObject } from "../core/immutable.js";
 import { validateGeneratedItemLimit } from "../core/validation.js";
 
 export const MAX_PATH_COMMANDS = 30_000;
@@ -13,6 +13,7 @@ const COMMAND_KEYS = Object.freeze({
   C: Object.freeze(["op", "x1", "y1", "x2", "y2", "x", "y"]),
   Z: Object.freeze(["op"])
 });
+const validatedCommands = new WeakSet();
 
 function validateCommand(command, index) {
   if (!isPlainObject(command) || !Object.hasOwn(COMMAND_KEYS, command.op)) {
@@ -41,6 +42,7 @@ function validateCommand(command, index) {
 }
 
 export function validatePathCommands(commands) {
+  if (validatedCommands.has(commands)) return commands;
   if (!Array.isArray(commands) || commands.length < 1) {
     throw new TypeError("path.commands must contain at least one command.");
   }
@@ -49,7 +51,10 @@ export function validatePathCommands(commands) {
   if (commands[0].op !== "M") {
     throw new Error("path.commands must start with M.");
   }
-  if (commands.length === 1) return commands;
+  if (commands.length === 1) {
+    if (isOwned(commands)) validatedCommands.add(commands);
+    return commands;
+  }
   if (commands.slice(1).some(command => command.op === "M")) {
     throw new Error("path.commands supports one subpath and only one initial M.");
   }
@@ -60,6 +65,7 @@ export function validatePathCommands(commands) {
   if (closeIndex !== -1 && closeIndex !== commands.length - 1) {
     throw new Error("path.commands Z must be the final command.");
   }
+  if (isOwned(commands)) validatedCommands.add(commands);
   return commands;
 }
 

package/src/grammar/pathSeries.js

@@ -1 +1 @@
-import{validateNonEmptyString as S}from"../core/validation.js";import{readCategoricalLineColor as p,validateCategoricalColorConsumer as y}from"./scales/colorConsumers.js";import{readNominalField as f,readQuantitativeField as O,readScaleField as x}from"./scales/fields.js";function m(n){const e=Array.isArray(n)?[...n]:[n];for(const i of e)S(i,"Path group field");if(e.length===0||new Set(e).size!==e.length)throw new Error("Path group fields must be non-empty and unique.");return e}function E(n){const e=n.encoding?.group;if(e!==void 0){if(e.fieldType!=="nominal")throw new Error(`Path group on mark "${n.id}" must be nominal.`);if(Object.hasOwn(e,"field")&&Object.hasOwn(e,"fields"))throw new Error("Path group requires exactly one of field or fields.");return m(e.fields??e.field)}if(n.mark?.type!=="line")return[];const i=["nominal","ordinal"].includes(n.encoding?.color?.fieldType)?n.encoding.color.field:void 0,o=n.encoding?.strokeDash?.field;if(i!==void 0&&o!==void 0&&i!==o)throw new Error("Line color field must match strokeDash field unless encodeGroup defines the series.");return i===void 0&&o===void 0?[]:[i??o]}function h(n){return JSON.stringify(n.map(e=>e===void 0?{}:e))}function g(n,e){const i=n.encoding?.color,o=Array.isArray(e)?e.find(t=>t.id===i?.scale):e?.[i?.scale];return o!==void 0&&y(n,i,o)?o:void 0}function P(n,e,i){const o=E(e),t=g(e,i);for(const r of o)t&&e.encoding?.group===void 0&&r===e.encoding.color.field?p(n,r):f(n,r);return o}function k(n,e,i,o,t={},r){const l=o==="strokeWidth"||o==="opacity",d=o==="color"&&r!==void 0?p(n,i):o==="stroke"||o==="color"&&["quantitative","temporal"].includes(t.fieldType)?x(n,i,t.fieldType??"nominal",{temporalUnit:t.temporalUnit}):l?O(n,i):f(n,i),a=new Map;return n.forEach((c,v)=>{const s=h(e.map(w=>c[w])),u=d[v];if(o==="strokeWidth"&&u<0)throw new RangeError(`Line strokeWidth field "${i}" cannot contain negative values.`);if(a.has(s)&&a.get(s)!==u)throw new Error(`Path ${o} field "${i}" must have one value within each series.`);a.set(s,u)}),a}function F(n,e,i,o,t,r){if(e.length===0)return[];const l=Object.keys(e[0]?.key??{}),d=k(n,l,i,o,t,Object.hasOwn(r??{},"unknown")?r:void 0);return e.map(a=>d.get(h(Object.values(a.key))))}function j(n,e,i,o){if(!["line","area"].includes(e.mark?.type)||e.encoding?.parallel!==void 0)return;const t=o??P(n,e,i);if(o!==void 0)for(const d of t)f(n,d);const r=g(e,i),l=e.mark.type==="line"?["color","stroke","strokeDash","strokeWidth","opacity"]:["color","stroke"];for(const d of l){const a=e.encoding?.[d];if(a?.field===void 0)continue;if(!(["color","stroke"].includes(d)?d==="color"?e.mark.type==="area"?["nominal","ordinal","quantitative"]:["nominal","ordinal","quantitative","temporal"]:["nominal","ordinal","quantitative","temporal"]:d==="strokeDash"?["nominal","ordinal"]:["quantitative"]).includes(a.fieldType))throw new Error(`Path ${d} encoding has an unsupported field type.`);k(n,t,a.field,d,a,d==="color"?r:void 0)}return t}function A(n,e){const i=e.encoding?.group,o=i===void 0?[]:m(i.fields??i.field);for(const r of o)f(n,r);const t=n.map(r=>o.length===0?void 0:o.length===1?r[o[0]]:JSON.stringify(o.map(l=>r[l])));return{fields:o,values:t,domain:[...new Set(t)]}}export{F as derivePathSeriesFieldValues,m as normalizeGroupFields,E as pathGroupFields,h as pathSeriesKey,P as readPathSeriesFields,A as readSeriesIdentity,j as validatePathSeriesAppearance};
+import{validateNonEmptyString as y}from"../core/validation.js";import{readCategoricalLineColor as p,validateCategoricalColorConsumer as S}from"./scales/colorConsumers.js";import{readNominalField as f,readQuantitativeField as O,readScaleField as x}from"./scales/fields.js";function m(n){const e=Array.isArray(n)?[...n]:[n];for(const i of e)y(i,"Path group field");if(e.length===0||new Set(e).size!==e.length)throw new Error("Path group fields must be non-empty and unique.");return e}function E(n){const e=n.encoding?.group;if(e!==void 0){if(e.fieldType!=="nominal")throw new Error(`Path group on mark "${n.id}" must be nominal.`);if(Object.hasOwn(e,"field")&&Object.hasOwn(e,"fields"))throw new Error("Path group requires exactly one of field or fields.");return m(e.fields??e.field)}if(n.mark?.type!=="line")return[];const i=["nominal","ordinal"].includes(n.encoding?.color?.fieldType)?n.encoding.color.field:void 0,o=n.encoding?.strokeDash?.field;if(i!==void 0&&o!==void 0&&i!==o)throw new Error("Line color field must match strokeDash field unless encodeGroup defines the series.");return i===void 0&&o===void 0?[]:[i??o]}function h(n){return JSON.stringify(n.map(e=>e===void 0?{}:e))}function g(n,e){const i=n.encoding?.color,o=Array.isArray(e)?e.find(t=>t.id===i?.scale):e?.[i?.scale];return o!==void 0&&S(n,i,o)?o:void 0}function P(n,e,i){const o=E(e),t=g(e,i);for(const r of o)t&&e.encoding?.group===void 0&&r===e.encoding.color.field?p(n,r):f(n,r);return o}function k(n,e,i,o,t={},r){const l=o==="strokeWidth"||o==="opacity",d=o==="color"&&r!==void 0?p(n,i):o==="stroke"||o==="color"&&["quantitative","temporal"].includes(t.fieldType)?x(n,i,t.fieldType??"nominal",{temporalUnit:t.temporalUnit}):l?O(n,i):f(n,i),a=new Map;return n.forEach((u,v)=>{const c=h(e.map(w=>u[w])),s=d[v];if(o==="strokeWidth"&&s<0)throw new RangeError(`Line strokeWidth field "${i}" cannot contain negative values.`);if(a.has(c)&&a.get(c)!==s)throw new Error(`Path ${o} field "${i}" must have one value within each series.`);a.set(c,s)}),a}function F(n,e,i,o,t,r){if(e.length===0)return[];const l=Object.keys(e[0]?.key??{}),d=k(n,l,i,o,t,Object.hasOwn(r??{},"unknown")?r:void 0);return e.map(a=>d.get(h(Object.values(a.key))))}function j(n,e,i,o){if(!["line","area"].includes(e.mark?.type)||e.encoding?.parallel!==void 0)return;const t=o??P(n,e,i);if(o!==void 0)for(const d of t)f(n,d);const r=g(e,i),l=e.mark.type==="line"?["color","stroke","strokeDash","strokeWidth","opacity"]:["color","stroke","opacity"];for(const d of l){const a=e.encoding?.[d];if(a?.field===void 0)continue;if(!(["color","stroke"].includes(d)?d==="color"?e.mark.type==="area"?["nominal","ordinal","quantitative"]:["nominal","ordinal","quantitative","temporal"]:["nominal","ordinal","quantitative","temporal"]:d==="strokeDash"?["nominal","ordinal"]:["quantitative"]).includes(a.fieldType))throw new Error(`Path ${d} encoding has an unsupported field type.`);k(n,t,a.field,d,a,d==="color"?r:void 0)}return t}function A(n,e){const i=e.encoding?.group,o=i===void 0?[]:m(i.fields??i.field);for(const r of o)f(n,r);const t=n.map(r=>o.length===0?void 0:o.length===1?r[o[0]]:JSON.stringify(o.map(l=>r[l])));return{fields:o,values:t,domain:[...new Set(t)]}}export{F as derivePathSeriesFieldValues,m as normalizeGroupFields,E as pathGroupFields,h as pathSeriesKey,P as readPathSeriesFields,A as readSeriesIdentity,j as validatePathSeriesAppearance};

package/src/grammar/plotComposition.js

@@ -0,0 +1,152 @@
+// One constructor capability registry for layering, adjacent inference and
+// inspection. Native constructors remain responsible for statistical work.
+const xy = ['createScatterPlot','createLinePlot','createBarPlot','createAreaPlot','createStripPlot','createBeeswarmPlot','createRegressionPlot','createTextPlot'];
+const summaryXY = ['createBoxPlot','createViolinPlot','createGradientPlot','createIntervalPlot'];
+export const PLOT_COMPOSITION_ROLES = Object.freeze(Object.fromEntries([
+  ...xy.map(a => [a, 'xy']), ...summaryXY.map(a => [a, 'summaryXY']),
+  ...['createDotPlot','createLollipopPlot','createDumbbellPlot'].map(a => [a, 'endpoint']),
+  ['createRaincloudPlot','categoryValue'], ['createHistogram','histogram'], ['createDensityPlot','density'],
+  ['createECDFPlot','ecdf'], ['createRugPlot','rug'], ['createHeatmap','heatmap'], ['createHorizonPlot','horizon'],
+  ...['createPolarScatterPlot','createPolarLinePlot'].map(a => [a, 'polar']),
+  ...['createPiePlot','createRosePlot','createRadialBarPlot'].map(a => [a, 'radial']),
+  ['createRadarPlot','radar'], ['createParallelCoordinates','parallel']
+]));
+export const COMPOSITION_PLOT_ACTIONS = Object.freeze(Object.keys(PLOT_COMPOSITION_ROLES));
+export const fieldEncoding = value => typeof value === 'string' ? { field:value } : value;
+const categorical = c => c && ['nominal','ordinal'].includes(c.fieldType);
+const encoding = (c, aggregate = true) => c?.field ? { field:c.field, fieldType:c.fieldType,
+  ...(aggregate && c.measurement.operations.length === 1 && ['mean','median','sum','min','max','count'].includes(c.measurement.operations[0]) ? { aggregate:c.measurement.operations[0] } : {}),
+  ...(c.bin ? { bin:c.bin } : {}), ...(c.temporalUnit ? { temporalUnit:c.temporalUnit } : {}) } : undefined;
+const plain = c => c?.field ? { field:c.field, fieldType:c.fieldType } : undefined;
+const merge = (base, supplied) => {
+  const value=typeof supplied==='string'?{field:supplied}:supplied;
+  // An explicit new field owns its type/grain. Source defaults only fill an
+  // omitted role or an options-only patch on that inferred field.
+  if (value?.field !== undefined && value.field !== base?.field || value?.lower !== undefined || value?.upper !== undefined) return value;
+  const merged={ ...base, ...value };
+  if (value?.center !== undefined || value?.extent !== undefined) {
+    // Native interval measurements are not ordinary field encodings.
+    for (const key of ['fieldType','temporalUnit','aggregate','bin']) delete merged[key];
+  }
+  return merged;
+};
+
+export function inferCompositionOptions(source, action, supplied = {}, inherit = {}) {
+  if (!inherit || typeof inherit !== 'object' || Array.isArray(inherit) ||
+      Object.keys(inherit).some(key => key !== 'color') ||
+      inherit.color !== undefined && typeof inherit.color !== 'boolean') {
+    throw new TypeError('Plot inheritance accepts color: true or false.');
+  }
+  const kind = PLOT_COMPOSITION_ROLES[action];
+  if (!kind) throw new Error(`Unknown plot constructor "${action}".`);
+  const c = source.channels;
+  const x = c.x ?? c.theta, y = c.y ?? c.radius;
+  const categoryAxis = categorical(x) ? 'x' : categorical(y) ? 'y' : undefined;
+  const category = categoryAxis === 'x' ? x : categoryAxis === 'y' ? y : undefined;
+  const measure = categoryAxis === 'x' ? y : categoryAxis === 'y' ? x : x;
+  let defaults = { data: source.data };
+  if (['xy','summaryXY','heatmap','horizon'].includes(kind)) {
+    defaults.x = kind === 'xy' && ['createLinePlot','createBarPlot'].includes(action) ? encoding(x) : plain(x);
+    defaults.y = kind === 'xy' && ['createLinePlot','createBarPlot'].includes(action) ? encoding(y) : plain(y);
+    if (kind === 'summaryXY') {
+      if (!categoryAxis && !(supplied.x !== undefined && supplied.y !== undefined)) throw new Error(`${action} requires one category axis and one quantitative measure.`);
+      if (categoryAxis && action === 'createIntervalPlot') defaults[categoryAxis === 'x' ? 'y' : 'x'] = { field:measure.field, center:'mean', extent:'ci', level:0.95 };
+    }
+    // Binning follows the new chart's roles, including explicitly supplied
+    // categorical/ordinal grids, rather than the source chart's old axes.
+    if (kind === 'heatmap' && !['x', 'y'].some(axis => categorical(
+      supplied[axis] === undefined ? defaults[axis] : merge(defaults[axis], supplied[axis])
+    ))) defaults.bin = { bins:12 };
+    if (kind === 'horizon' && c.y?.measurement.parameters) Object.assign(defaults, c.y.measurement.parameters);
+    if (action === 'createTextPlot') defaults.text = { field:c.color?.field ?? y?.field ?? x?.field };
+  } else if (['endpoint','categoryValue'].includes(kind)) {
+    if (!categoryAxis && !(supplied.category !== undefined && (supplied.value !== undefined || supplied.end !== undefined))) throw new Error(`${action} requires one category axis and one quantitative measure.`);
+    if (categoryAxis) Object.assign(defaults, {category:plain(category), orientation: categoryAxis === 'x' ? 'vertical' : 'horizontal'});
+    if (action === 'createDumbbellPlot') { defaults.end=plain(measure); } else defaults.value=plain(measure);
+    if (kind === 'endpoint') defaults.summary=['mean','median','sum','min','max'].includes(measure?.measurement.operations.at(-1))?measure.measurement.operations.at(-1):'mean';
+  } else if (['histogram','density','ecdf'].includes(kind)) {
+    defaults.field = supplied.field ?? measure?.field;
+    if (kind === 'density' && c.x?.measurement.unit === 'density') defaults.densityChannel='x';
+    if (kind === 'histogram' && x?.bin) {
+      defaults.maxBins=x.bin.maxBins; defaults.binStep=x.bin.step; defaults.binBoundaries=x.bin.boundaries;
+    }
+    if (inherit.color !== false && kind === 'density' && c.color?.field && categorical(c.color)) defaults.groupBy=c.color.field;
+  } else if (kind === 'rug') {
+    const axis = supplied.x !== undefined ? 'x' : supplied.y !== undefined ? 'y'
+      : supplied.edge === 'left' || supplied.edge === 'right' || categorical(c.x) ? 'y' : 'x';
+    defaults[axis] = plain(c[axis]); defaults.edge = axis === 'x' ? 'bottom' : 'left';
+  } else if (kind === 'polar') {
+    defaults.theta=plain(c.theta); defaults.radius=plain(c.radius);
+    if (action === 'createPolarLinePlot' && source.groupBy) defaults.groupBy=source.groupBy;
+  } else if (kind === 'radial') {
+    defaults.category=plain(c.theta);
+    defaults.aggregate=c.radius?.measurement.operations.at(-1) ?? c.theta?.measurement.parameters?.aggregate ?? 'count';
+    if(defaults.aggregate==='sum') defaults.value=c.radius?.field ?? c.theta?.measurement.parameters?.weight;
+  } else if (kind === 'radar') {
+    if (c.theta?.fields) defaults.wide={fields:c.theta.fields};
+    else {defaults.category=plain(c.theta); defaults.value=plain(c.radius);}
+    if (source.groupBy) defaults.groupBy=source.groupBy;
+  } else if (kind === 'parallel') defaults.dimensions=source.dimensions?.map(plain);
+  if (inherit.color !== false && c.color?.field && !['heatmap', 'horizon', 'rug'].includes(kind)) {
+    const summaryCategoryOnly = ['endpoint','categoryValue','summaryXY'].includes(kind) && action !== 'createIntervalPlot';
+    const colorSurvives = !summaryCategoryOnly || c.color.field === category?.field ||
+      action === 'createViolinPlot' && supplied.split?.field === c.color.field;
+    if (colorSurvives) defaults.color=plain(c.color);
+    if (action === 'createIntervalPlot' && categorical(c.color) && c.color.field !== category?.field) defaults.groupBy=c.color.field;
+  }
+  if (action === 'createAreaPlot') {
+    // Explicit native X/Y roles follow the native default value channel. The
+    // source orientation only applies when the new roles are inferred.
+    const axis = supplied.valueChannel ?? (supplied.x !== undefined && supplied.y !== undefined ? 'y' : categoryAxis === 'y' ? 'x' : 'y'); defaults.valueChannel=axis;
+    if(defaults[axis]) defaults[axis]={field:defaults[axis].field};
+  }
+  if (['createLinePlot','createAreaPlot'].includes(action) && source.groupBy) defaults.groupBy=source.groupBy;
+  if (inherit.color !== false && c.color?.field &&
+      (kind==='ecdf' || action==='createAreaPlot' && !defaults.groupBy && categorical(c.color))) defaults.groupBy=[c.color.field];
+  const result={...defaults,...supplied};
+  for(const key of ['x','y','category','value','theta','radius','color','end']) {
+    if (supplied[key] !== undefined && defaults[key] !== undefined) result[key]=merge(defaults[key],supplied[key]);
+  }
+  return Object.fromEntries(Object.entries(result).filter(([,v])=>v!==undefined));
+}
+
+// Describe prospective roles without constructing/rendering a candidate chart.
+export function constructorChannels(action, options, source) {
+  const kind=PLOT_COMPOSITION_ROLES[action], c=source.channels, result={};
+  const add=(channel,value,path,operation) => {
+    const e=fieldEncoding(value); if(!e?.field) return;
+    const reference=c[channel]?.field===e.field?c[channel]:Object.values(c).find(r=>r.field===e.field);
+    result[channel]={ field:e.field,fieldType:e.fieldType??reference?.fieldType??'quantitative',
+      operations:operation ? [operation] : e.aggregate ? [e.aggregate] : [],
+      ...(e.temporalUnit ? {temporalUnit:e.temporalUnit}:{}), ...(e.bin ? {bin:e.bin}:{}), path };
+  };
+  if(['xy','summaryXY','heatmap','horizon'].includes(kind)) {
+    add('x',options.x,'x.scale'); add('y',options.y,'y.scale');
+    if(kind==='horizon' && result.y) result.y.operations=['folded'];
+  } else if(['endpoint','categoryValue'].includes(kind)) {
+    const axis=options.orientation==='horizontal'?'y':'x', measureAxis=axis==='x'?'y':'x';
+    add(axis,options.category,'category.scale');
+    add(measureAxis,options.value??options.end,options.value?'value.scale':'end.scale',kind==='endpoint'?options.summary:undefined);
+  } else if(kind==='histogram') {
+    add('x',options.field,'xScale'); add('y',options.weight??options.field,'yScale',options.weight?'sum':'count');
+  } else if(kind==='density') {
+    const density=options.densityChannel??'y', value=density==='y'?'x':'y';
+    add(value,options.field,'valueScale'); add(density,options.field,'densityScale','density');
+  } else if(kind==='ecdf') {
+    const value=options.orientation==='horizontal'?'y':'x';
+    add(value,options.field,'valueScale'); add(value==='x'?'y':'x',options.field,'probabilityScale','probability');
+  } else if(kind==='rug') {
+    add('x',options.x,'x.scale'); add('y',options.y,'y.scale');
+  } else if(kind==='polar') {
+    add('theta',options.theta,'theta.scale'); add('radius',options.radius,'radius.scale');
+  } else if(kind==='radial') {
+    add('theta',options.category,'category.scale');
+    if(action!=='createPiePlot') {
+      if(options.aggregate==='count') result.radius={fieldType:'quantitative',operations:['count'],path:'radiusScale'};
+      else add('radius',options.value,'radiusScale',options.aggregate);
+    } else if(result.theta) result.theta.operations=['partition'];
+  } else if(kind==='radar' && !options.wide) {
+    add('theta',options.category,'category.scale'); add('radius',options.value,'value.scale');
+  }
+  return result;
+}

package/src/grammar/pointShapes.js

@@ -20,6 +20,24 @@ export const POINT_SHAPES = cloneAndFreeze([
   "arrow"
 ]);
 
+// Recover the anchor from concrete geometry, including jitter, packing and rotation.
+// Path glyphs can be asymmetric, so their bounding-box center is not their anchor.
+export function pointGraphicAnchor(graphic, shape = "circle", angle) {
+  const p = graphic?.properties ?? {};
+  if (graphic?.type === "circle") return { x: p.x, y: p.y };
+  if (graphic?.type === "rect") return { x: p.x + p.width / 2, y: p.y + p.height / 2 };
+  const template = createPointShapeGraphic({ shape, angle, x: 0, y: 0, area: 1, fill: "black" });
+  const points = p.commands?.filter(command => Number.isFinite(command.x) && Number.isFinite(command.y));
+  const origin = template.properties.commands?.filter(command => Number.isFinite(command.x) && Number.isFinite(command.y));
+  if (!points?.length || points.length !== origin?.length) throw new Error("Point glyph does not match its shape geometry.");
+  const bounds = values => ({ left: Math.min(...values.map(p => p.x)), right: Math.max(...values.map(p => p.x)),
+    top: Math.min(...values.map(p => p.y)), bottom: Math.max(...values.map(p => p.y)) });
+  const actual = bounds(points), unit = bounds(origin);
+  const factor = unit.right !== unit.left ? (actual.right - actual.left) / (unit.right - unit.left)
+    : (actual.bottom - actual.top) / (unit.bottom - unit.top);
+  return { x: actual.left - factor * unit.left, y: actual.top - factor * unit.top };
+}
+
 const SHAPE_SET = new Set(POINT_SHAPES);
 
 export function validatePointShape(shape) {

package/src/grammar/scales/transformed.js

@@ -1 +1 @@
-import{cloneAndFreeze as h,isPlainObject as I}from"../../core/immutable.js";import{MAX_GENERATED_ITEMS as R}from"../../core/validation.js";import{interpolateNumber as D,inverseLerp as b,numericExtent as q}from"../numeric.js";import{niceTicks as $}from"../ticks.js";import{niceLinearDomain as j}from"./continuous.js";import{SCALE_ROLES as L,validateScaleTypeForRole as A}from"./types.js";import{validatePair as _}from"./validation.js";const z=Object.freeze(["log","pow","sqrt","symlog"]);function v(t,e){if(!Number.isFinite(t)||t<=0)throw new RangeError(`${e} must be a positive finite number.`);return t}function p(t,e={}){if(!z.includes(t)&&t!=="linear")throw new Error(`Scale type "${t}" is not a quantitative transform.`);if(!I(e))throw new TypeError("Scale transform options must be a plain object.");const o=t==="log"?["base"]:t==="pow"?["exponent"]:t==="symlog"?["constant"]:[];for(const n of Object.keys(e))if(!o.includes(n))throw new Error(`Scale type "${t}" does not support ${n}.`);if(t==="log"){const n=v(e.base??10,"Log scale base");if(n===1)throw new RangeError("Log scale base must not equal 1.");return h({base:n})}return t==="pow"?h({exponent:v(e.exponent??1,"Power scale exponent")}):t==="sqrt"?h({exponent:.5}):t==="symlog"?h({constant:v(e.constant??1,"Symlog scale constant")}):h({})}function E(t,e,o,n){const r=[e,o,t].map(i=>Math.sign(i)*n(Math.abs(i)));return r[0]!==r[1]&&r.every(Number.isFinite)?b(r[2],r[0],r[1]):void 0}function V(t,e,o){const[n,r]=e,i=E(t,n,r,c=>c**o);if(i!==void 0)return i;const s=Math.max(Math.abs(n),Math.abs(r)),a=E(t,n,r,c=>c===0?0:Math.exp(o*(Math.log(c)-Math.log(s))));if(a!==void 0)return a;if(n!==0&&r!==0&&t!==0&&Math.sign(n)===Math.sign(r)){const c=Math.log(Math.abs(r))-Math.log(Math.abs(n)),f=Math.log(Math.abs(t))-Math.log(Math.abs(n));if(Math.abs(o*c)<1e-8)return f/c;const u=Math.expm1(o*f)/Math.expm1(o*c);if(Number.isFinite(u))return u}return b(t,n,r)}function N(t,e){if(t===0)return 0;const o=Math.abs(t)/e;if(Number.isFinite(o))return Math.sign(t)*Math.log1p(o);const n=Math.log(Math.abs(t))-Math.log(e);return Math.sign(t)*(Math.max(0,n)+Math.log1p(Math.exp(-Math.abs(n))))}function C(t,e,o,n){const[r,i]=e;if(o==="linear")return b(t,r,i);if(o==="log"){const f=Math.log10(n.base);return E(t,r,i,d=>Math.log10(d)/f)??E(t,r,i,Math.log)??b(t,r,i)}if(o==="pow"||o==="sqrt")return V(t,e,n.exponent);const s=N(r,n.constant),a=N(i,n.constant);if(s===a)return b(t,r,i);const c=b(N(t,n.constant),s,a);return Number.isFinite(c)?c:b(t,r,i)}function x(t,e,o={}){A(t,L.quantitativePosition);const n=_(e,"Transformed scale domain");if(n[0]===n[1])throw new RangeError("Transformed scale domain values must be distinct.");if(t==="log"&&(n.includes(0)||Math.sign(n[0])!==Math.sign(n[1])))throw new RangeError("Log scale domain must be strictly positive or strictly negative.");return p(t,o),n}function P(t,e,o){const n=Number.isFinite(t)?t**e:Number.NaN;if(Number.isFinite(n)&&n>0)return n;const r=e*o;return r>Math.log(Number.MAX_VALUE)?Number.POSITIVE_INFINITY:r<Math.log(Number.MIN_VALUE)?0:Math.exp(r)}function O(t,e){const o=Math.min(...t),n=Math.max(...t),r=n<0;return[e<1?-Math.log(e):Math.log(e),e<1?1/e:e,t[0]>t[1],r,r?Math.abs(n):o,r?Math.abs(o):n]}function U(t,e){const[o,n,r,i,s,a]=O(t,e);let c=P(n,Math.floor(Math.log(s)/o),o),f=P(n,Math.ceil(Math.log(a)/o),o);(!Number.isFinite(c)||c<=0||c>s)&&(c=s),(!Number.isFinite(f)||f<a)&&(f=a);const u=i?[-f,-c]:[c,f];return h(r?u.reverse():u)}function X(t,e,o){const n=p(t,o);if(e===0){if(t==="log")throw new RangeError("Log scale domain must be strictly positive or strictly negative.");return[-1,1]}const r=Math.abs(e);let i=r/2,s=r*2;if(t==="pow"||t==="sqrt")s=r*(2-2**-n.exponent)**(1/n.exponent);else if(t==="symlog"){const a=Math.abs(N(e,n.constant));if(a===0)return[-1,1];s=n.constant*Math.expm1(2*a-N(i,n.constant))}return i<r&&s>r&&Number.isFinite(s)||(i=r/2,s=Number.isFinite(r*2)?r*2:r),t==="log"&&i===0&&(i=r),e>0?[i,s]:[-s,i===0?0:-i]}function W({type:t,domain:e="auto",values:o,nice:n=!1,zero:r=!1,...i}){if(A(t,L.quantitativePosition),!Array.isArray(o)||!o.every(Number.isFinite))throw new TypeError("Transformed scale values must be finite numbers.");if(typeof n!="boolean"||typeof r!="boolean")throw new TypeError("Scale nice and zero must be booleans.");if(t==="log"&&r)throw new Error('Scale type "log" does not support zero.');if(e!=="auto")return x(t,e,i);if(o.length===0)throw new Error("Cannot infer an automatic scale domain from no values.");let a=q(o);return r&&(a=[Math.min(0,a[0]),Math.max(0,a[1])]),a[0]===a[1]&&(a=X(t,a[0],i)),x(t,a,i),n&&(a=t==="log"?U(a,p(t,i).base):j(a)),x(t,a,i)}function Y(t,{reverse:e=!1}={}){const o=_(t,"Scale range");if(typeof e!="boolean")throw new TypeError("Scale reverse must be a boolean.");return e?h([...o].reverse()):o}function Z(t,e,o,{type:n="linear",clamp:r=!1,reverse:i=!1,...s}={}){if(!Array.isArray(t))throw new TypeError("Scale values must be an array.");if(typeof r!="boolean")throw new TypeError("Scale clamp must be a boolean.");const a=Object.hasOwn(s,"unknown"),{unknown:c,...f}=s,u=p(n,f),d=x(n,e,f),l=Y(o,{reverse:i}),w=l[1]-l[0];return h(t.map(g=>{if(!(Number.isFinite(g)&&!(n==="log"&&(g===0||Math.sign(g)!==Math.sign(d[0]))))){if(a)return c;throw new TypeError(`Scale type "${n}" received an invalid value.`)}let m=C(g,d,n,u);r&&(m=Math.max(0,Math.min(1,m)));const M=l[0]+m*w;return Number.isFinite(w)&&Number.isFinite(M)&&(m!==1||Math.abs(M-l[1])<=Number.EPSILON*Math.abs(l[1]))?M:D(l[0],l[1],m)}))}function tt(t,e,o,n={}){const r=x(t,e,n);if(!Number.isInteger(o)||o<=0)throw new RangeError("Tick count must be a positive integer.");if(t!=="log")return $(r,o);const{base:i}=p(t,n),[s,a,c,f,u,d]=O(r,i),l=Math.ceil(Math.log(u)/s-1e-12),w=Math.floor(Math.log(d)/s+1e-12),g=w-l+1,T=g<=R?g:Math.min(o,R),m=[];for(let M=0;M<T;M+=1){const k=g<=R?l+M:Math.round(l+(w-l)*M/Math.max(1,T-1)),S=P(a,k,s),F=(f?-1:1)*S;Number.isFinite(F)&&S>=u&&S<=d&&(m.length===0||F!==m.at(-1))&&m.push(F)}return f&&m.reverse(),c&&m.reverse(),h(m.length===0?[...r]:m)}function nt(t,e){if(t!=="log")return String(e);const o=Math.abs(e),r=[[1e9,"B"],[1e6,"M"],[1e3,"K"]].find(([s])=>o>=s);if(r===void 0)return String(e);const i=e/r[0];return`${Number(i.toPrecision(3))}${r[1]}`}export{nt as formatTransformedTick,Z as mapTransformedValues,p as normalizeTransformParameters,Y as resolveMappingRange,W as resolveTransformedDomain,tt as transformedTicks,x as validateTransformedDomain};
+import{cloneAndFreeze as M,isPlainObject as D}from"../../core/immutable.js";import{MAX_GENERATED_ITEMS as T}from"../../core/validation.js";import{interpolateNumber as R,inverseLerp as w,numericExtent as q}from"../numeric.js";import{niceTicks as $}from"../ticks.js";import{niceLinearDomain as j}from"./continuous.js";import{SCALE_ROLES as L,validateScaleTypeForRole as _}from"./types.js";import{validatePair as I}from"./validation.js";const y=Object.freeze(["log","pow","sqrt","symlog"]);function P(t,e){if(!Number.isFinite(t)||t<=0)throw new RangeError(`${e} must be a positive finite number.`);return t}function p(t,e={}){if(!y.includes(t)&&t!=="linear")throw new Error(`Scale type "${t}" is not a quantitative transform.`);if(!D(e))throw new TypeError("Scale transform options must be a plain object.");const o=t==="log"?["base"]:t==="pow"?["exponent"]:t==="symlog"?["constant"]:[];for(const r of Object.keys(e))if(!o.includes(r))throw new Error(`Scale type "${t}" does not support ${r}.`);if(t==="log"){const r=P(e.base??10,"Log scale base");if(r===1)throw new RangeError("Log scale base must not equal 1.");return M({base:r})}return t==="pow"?M({exponent:P(e.exponent??1,"Power scale exponent")}):t==="sqrt"?M({exponent:.5}):t==="symlog"?M({constant:P(e.constant??1,"Symlog scale constant")}):M({})}function S(t,e,o,r){const n=[e,o,t].map(i=>Math.sign(i)*r(Math.abs(i)));return n[0]!==n[1]&&n.every(Number.isFinite)?w(n[2],n[0],n[1]):void 0}function z(t,e,o){const[r,n]=e,i=S(t,r,n,c=>c**o);if(i!==void 0)return i;const s=Math.max(Math.abs(r),Math.abs(n)),a=S(t,r,n,c=>c===0?0:Math.exp(o*(Math.log(c)-Math.log(s))));if(a!==void 0)return a;if(r!==0&&n!==0&&t!==0&&Math.sign(r)===Math.sign(n)){const c=Math.log(Math.abs(n))-Math.log(Math.abs(r)),m=Math.log(Math.abs(t))-Math.log(Math.abs(r));if(Math.abs(o*c)<1e-8)return m/c;const f=Math.expm1(o*m)/Math.expm1(o*c);if(Number.isFinite(f))return f}return w(t,r,n)}function x(t,e){if(t===0)return 0;const o=Math.abs(t)/e;if(Number.isFinite(o))return Math.sign(t)*Math.log1p(o);const r=Math.log(Math.abs(t))-Math.log(e);return Math.sign(t)*(Math.max(0,r)+Math.log1p(Math.exp(-Math.abs(r))))}function V(t,e,o,r){const[n,i]=e;if(o==="linear")return w(t,n,i);if(o==="log"){const m=Math.log10(r.base);return S(t,n,i,g=>Math.log10(g)/m)??S(t,n,i,Math.log)??w(t,n,i)}if(o==="pow"||o==="sqrt")return z(t,e,r.exponent);const s=x(n,r.constant),a=x(i,r.constant);if(s===a)return w(t,n,i);const c=w(x(t,r.constant),s,a);return Number.isFinite(c)?c:w(t,n,i)}function N(t,e,o={}){_(t,L.quantitativePosition);const r=I(e,"Transformed scale domain");if(r[0]===r[1])throw new RangeError("Transformed scale domain values must be distinct.");if(t==="log"&&(r.includes(0)||Math.sign(r[0])!==Math.sign(r[1])))throw new RangeError("Log scale domain must be strictly positive or strictly negative.");return p(t,o),r}function A(t,e,o){const r=Number.isFinite(t)?t**e:Number.NaN;if(Number.isFinite(r)&&r>0)return r;const n=e*o;return n>Math.log(Number.MAX_VALUE)?Number.POSITIVE_INFINITY:n<Math.log(Number.MIN_VALUE)?0:Math.exp(n)}function O(t,e){const o=Math.min(...t),r=Math.max(...t),n=r<0;return[e<1?-Math.log(e):Math.log(e),e<1?1/e:e,t[0]>t[1],n,n?Math.abs(r):o,n?Math.abs(o):r]}function C(t,e){const[o,r,n,i,s,a]=O(t,e);let c=A(r,Math.floor(Math.log(s)/o),o),m=A(r,Math.ceil(Math.log(a)/o),o);(!Number.isFinite(c)||c<=0||c>s)&&(c=s),(!Number.isFinite(m)||m<a)&&(m=a);const f=i?[-m,-c]:[c,m];return M(n?f.reverse():f)}function U(t,e,o){const r=p(t,o);if(e===0){if(t==="log")throw new RangeError("Log scale domain must be strictly positive or strictly negative.");return[-1,1]}const n=Math.abs(e);let i=n/2,s=n*2;if(t==="pow"||t==="sqrt")s=n*(2-2**-r.exponent)**(1/r.exponent);else if(t==="symlog"){const a=Math.abs(x(e,r.constant));if(a===0)return[-1,1];s=r.constant*Math.expm1(2*a-x(i,r.constant))}return i<n&&s>n&&Number.isFinite(s)||(i=n/2,s=Number.isFinite(n*2)?n*2:n),t==="log"&&i===0&&(i=n),e>0?[i,s]:[-s,i===0?0:-i]}function W({type:t,domain:e="auto",values:o,nice:r=!1,zero:n=!1,...i}){if(_(t,L.quantitativePosition),!Array.isArray(o)||!o.every(Number.isFinite))throw new TypeError("Transformed scale values must be finite numbers.");if(typeof r!="boolean"||typeof n!="boolean")throw new TypeError("Scale nice and zero must be booleans.");if(t==="log"&&n)throw new Error('Scale type "log" does not support zero.');if(e!=="auto")return N(t,e,i);if(o.length===0)throw new Error("Cannot infer an automatic scale domain from no values.");let a=q(o);return n&&(a=[Math.min(0,a[0]),Math.max(0,a[1])]),a[0]===a[1]&&(a=U(t,a[0],i)),N(t,a,i),r&&(a=t==="log"?C(a,p(t,i).base):j(a)),N(t,a,i)}function X(t,{reverse:e=!1}={}){const o=I(t,"Scale range");if(typeof e!="boolean")throw new TypeError("Scale reverse must be a boolean.");return e?M([...o].reverse()):o}function Z(t,e,o,{type:r="linear",clamp:n=!1,reverse:i=!1,...s}={}){if(!Array.isArray(t))throw new TypeError("Scale values must be an array.");if(typeof n!="boolean")throw new TypeError("Scale clamp must be a boolean.");const a=Object.hasOwn(s,"unknown"),{unknown:c,...m}=s,f=p(r,m),g=N(r,e,m),l=X(o,{reverse:i}),d=l[1]-l[0];return M(t.map(h=>{if(!(Number.isFinite(h)&&!(r==="log"&&(h===0||Math.sign(h)!==Math.sign(g[0]))))){if(a)return c;throw new TypeError(`Scale type "${r}" received an invalid value.`)}let u=V(h,g,r,f);n&&(u=Math.max(0,Math.min(1,u)));const b=l[0]+u*d;return Number.isFinite(d)&&Number.isFinite(b)&&(u!==1||Math.abs(b-l[1])<=Number.EPSILON*Math.abs(l[1]))?b:R(l[0],l[1],u)}))}function tt(t,e,o,r={}){const n=N(t,e,r);if(!Number.isInteger(o)||o<=0)throw new RangeError("Tick count must be a positive integer.");if(t!=="log")return $(n,o);const{base:i}=p(t,r),[s,a,c,m,f,g]=O(n,i),l=Math.ceil(Math.log(f)/s-1e-12),d=Math.floor(Math.log(g)/s+1e-12),h=d-l+1,E=h<=T?h:Math.min(o,T),u=[];for(let b=0;b<E;b+=1){const k=h<=T?l+b:Math.round(l+(d-l)*b/Math.max(1,E-1)),F=A(a,k,s),v=(m?-1:1)*F;Number.isFinite(v)&&F>=f&&F<=g&&(u.length===0||v!==u.at(-1))&&u.push(v)}return m&&u.reverse(),c&&u.reverse(),M(u.length===0?[...n]:u)}function rt(t,e,o={}){const r=N("symlog",t,o);if(!Number.isInteger(e)||e<2||e>T)throw new RangeError(`Sample count must be an integer from 2 to ${T}.`);const{constant:n}=p("symlog",o),i=r.map(m=>x(m,n)),s=Math.min(...r),a=Math.max(...r),c=Array.from({length:e},(m,f)=>{if(f===0)return r[0];if(f===e-1)return r[1];const g=f/(e-1);if(i[0]===i[1])return R(...r,g);const l=R(...i,g),d=Math.abs(l),h=n*Math.expm1(d),E=Math.sign(l)*(Number.isFinite(h)?h:Math.exp(Math.log(n)+d+Math.log1p(-Math.exp(-d))));return Math.max(s,Math.min(a,E))});if(s<0&&a>0&&e>2){const m=Math.round(w(0,...i)*(e-1));m>0&&m<e-1&&(c[m]=0)}return M(c.filter((m,f)=>f===0||m!==c[f-1]))}function nt(t,e){if(t!=="log")return String(e);const o=Math.abs(e),n=[[1e9,"B"],[1e6,"M"],[1e3,"K"]].find(([s])=>o>=s);if(n===void 0)return String(e);const i=e/n[0];return`${Number(i.toPrecision(3))}${n[1]}`}export{nt as formatTransformedTick,Z as mapTransformedValues,p as normalizeTransformParameters,X as resolveMappingRange,W as resolveTransformedDomain,rt as sampleSymlogValues,tt as transformedTicks,N as validateTransformedDomain};

package/src/grammar/schemas/concreteGraphic.js

@@ -1,6 +1,6 @@
 import { validateGeneratedItemLimit } from "../../core/validation.js";
 import { validateFontStyle } from "../../core/font.js";
-import { isPlainObject } from "../../core/immutable.js";
+import { isOwned, isPlainObject } from "../../core/immutable.js";
 import { validatePathCommands } from "../pathCommands.js";
 import { validateFillPaint } from "../paint.js";
 import {
@@ -25,6 +25,7 @@ const TEXT_ALIGNS = new Set(["left", "right", "center", "start", "end"]);
 const TEXT_BASELINES = new Set([
   "top", "hanging", "middle", "alphabetic", "ideographic", "bottom"
 ]);
+const validatedProperties = new WeakMap();
 
 export function validateConcreteGraphicValue(type, property, value) {
   if (property === "lines") {
@@ -98,6 +99,8 @@ export function validateConcreteGraphicValue(type, property, value) {
 }
 
 export function validateConcreteGraphicProperties(type, properties) {
+  const validatedTypes = validatedProperties.get(properties);
+  if (validatedTypes?.has(type)) return properties;
   if (!isPlainObject(properties)) {
     throw new TypeError(`${type}.properties must be a plain object.`);
   }
@@ -105,5 +108,9 @@ export function validateConcreteGraphicProperties(type, properties) {
     validateGraphicProperty(type, property);
     validateConcreteGraphicValue(type, property, value);
   }
+  if (isOwned(properties)) {
+    if (validatedTypes) validatedTypes.add(type);
+    else validatedProperties.set(properties, new Set([type]));
+  }
   return properties;
 }

package/src/grammar/schemas/graphicBounds.js

@@ -3,6 +3,7 @@ import {
   resolveTextBounds
 } from "../../core/textMetrics.js";
 import { interpolateNumber } from "../numeric.js";
+import { isOwned } from "../../core/immutable.js";
 import { graphicClipBounds, intersectClipBounds } from "./graphicClip.js";
 import { resolveStrokeDetails } from "../strokeStyle.js";
 import {
@@ -12,6 +13,7 @@ import {
 } from "./graphicTree.js";
 
 const EPSILON = Number.EPSILON * 64;
+const pathBounds = new WeakMap();
 
 function box(left, right, top, bottom, extent = 0) {
   return {
@@ -111,6 +113,10 @@ function cubicExtrema(start, control1, control2, end) {
 }
 
 export function resolvePathCommandBounds(commands) {
+  if (pathBounds.has(commands)) {
+    const cached = pathBounds.get(commands);
+    return cached === undefined ? undefined : { ...cached };
+  }
   let bounds;
   let current;
   for (const command of commands) {
@@ -145,7 +151,8 @@ export function resolvePathCommandBounds(commands) {
     }
     current = { x: command.x, y: command.y };
   }
-  return bounds;
+  if (isOwned(commands)) pathBounds.set(commands, bounds);
+  return bounds === undefined ? undefined : { ...bounds };
 }
 
 function endpointDirection(start, command, end, reverse = false) {

package/src/grammar/schemas/graphicTree.js

@@ -1,4 +1,4 @@
-import { isPlainObject } from "../../core/immutable.js";
+import { isOwned, isPlainObject } from "../../core/immutable.js";
 import { isGraphicContainerType } from "./graphic.js";
 
 export function resolveGraphicChildOrder(graphicSpec, target, value) {
@@ -34,7 +34,7 @@ export function findGraphic(graphicSpec, target) {
     return { id: target, object, kind: "object" };
   }
   for (const [ownerId, owner] of Object.entries(graphicSpec.objects)) {
-    const itemIndex = owner.items?.findIndex(item => item.id === target);
+    const itemIndex = findItemIndex(owner.items, target);
     if (itemIndex !== undefined && itemIndex !== -1) {
       return {
         id: target,
@@ -49,6 +49,22 @@ export function findGraphic(graphicSpec, target) {
   return undefined;
 }
 
+// Collections are immutable across unrelated edits. Index their items once,
+// instead of scanning every point/path again for each label or inspection.
+// Caller-owned arrays remain uncached, including shallow-frozen inputs.
+const itemIndexes = new WeakMap();
+function findItemIndex(items, target) {
+  if (!items) return undefined;
+  if (!isOwned(items)) return items.findIndex(item => item.id === target);
+  let index = itemIndexes.get(items);
+  if (!index) {
+    index = new Map();
+    items.forEach((item, i) => { if (!index.has(item.id)) index.set(item.id, i); });
+    itemIndexes.set(items, index);
+  }
+  return index.get(target) ?? -1;
+}
+
 export function requireGraphic(graphicSpec, target) {
   const found = findGraphic(graphicSpec, target);
   if (found === undefined) {

package/src/grammar/schemas/semanticPath.js

@@ -68,6 +68,7 @@ const ENTITY_PATHS = Object.freeze({
       "mark.orientation",
       "mark.blend",
       "derivedBindings.regression",
+      "derivedBindings.overlay",
       "layout.mode",
       ...ENCODING_PATHS
     ])
@@ -106,6 +107,8 @@ const GUIDE_PATHS = new Set([
   "legend.colorSize.colorScale",
   "legend.colorSize.sizeScale",
   "legend.colorSize.title",
+  "legend.colorSize.shapeScale",
+  "legend.colorSize.colorChannel",
   "legend.color.scale",
   "legend.color.title",
   "legend.color.order",