ggaction 0.0.11 → 0.0.13

package/src/actions/guides/polar/axes/facade.js

@@ -1,5 +1,12 @@
 import { action } from "../../../../core/action.js";
-import { polarGuideNames, resolvePolarGuideResources } from "../resolve.js";
+import { resolvePolarGuideResources } from "../resolve.js";
+import {
+  AXIS_COMPONENTS,
+  assertRemovableAxisComponent,
+  hasAxisComponent,
+  removeAxisComponent,
+  validateEnabledAxisComponents
+} from "../../axes/components.js";
 import {
   LABEL_EDIT_OPTIONS,
   LINE_EDIT_OPTIONS,
@@ -22,12 +29,15 @@ const AXIS_EDIT_OPTIONS = Object.freeze([
   "angle", "line", "ticks", "labels", "ticksAndLabels", "title"
 ]);
 
-function validateAxisArgs(kind, args, operation) {
-  validateObject(args, AXIS_OPTIONS, operation);
-  if (Object.hasOwn(args, "line")) {
+export function validatePolarAxisArgs(kind, args, operation) {
+  validateObject(args, kind === "theta"
+    ? AXIS_OPTIONS.filter(option => option !== "angle")
+    : AXIS_OPTIONS, operation);
+  validateEnabledAxisComponents(args, operation);
+  if (Object.hasOwn(args, "line") && args.line !== false) {
     validateObject(args.line, LINE_EDIT_OPTIONS, `${operation}.line`);
   }
-  if (Object.hasOwn(args, "ticksAndLabels")) {
+  if (Object.hasOwn(args, "ticksAndLabels") && args.ticksAndLabels !== false) {
     validateObject(
       args.ticksAndLabels,
       TICK_GROUP_OPTIONS,
@@ -68,7 +78,7 @@ function makeCreateAxis(kind) {
     op: operation,
     description: `Create the complete Polar ${kind} axis.`
   }, function (args = {}) {
-    validateAxisArgs(kind, args, operation);
+    validatePolarAxisArgs(kind, args, operation);
     const resources = resolvePolarGuideResources(this, kind, args, operation);
     const angle = resolveAngle(this, kind, args);
     const shared = {
@@ -82,21 +92,16 @@ function makeCreateAxis(kind) {
       ...(Object.hasOwn(group, "values") ? { values: group.values } : {})
     };
     let next = this;
-    if (kind === "radius") {
-      next = next._withGuideConfig("radius", "layout", { angle });
+    if (args.line !== false) {
+      next = next[`create${prefix(kind)}AxisLine`]({ ...shared, ...(args.line ?? {}) });
     }
-    next = next
-      [`create${prefix(kind)}AxisLine`]({ ...shared, ...(args.line ?? {}) })
-      [`create${prefix(kind)}AxisTicks`]({
-        ...shared,
-        ...mode,
-        ...(group.ticks ?? {})
-      })
-      [`create${prefix(kind)}AxisLabels`]({
-        ...shared,
-        ...mode,
-        ...(group.labels ?? {})
+    if (args.ticksAndLabels !== false) {
+      next = next[`create${prefix(kind)}AxisTicks`]({
+        ...shared, ...mode, ...(group.ticks ?? {})
+      })[`create${prefix(kind)}AxisLabels`]({
+        ...shared, ...mode, ...(group.labels ?? {})
       });
+    }
     return args.title === false
       ? next
       : next[`create${prefix(kind)}AxisTitle`]({
@@ -118,29 +123,28 @@ function validateAxisEditArgs(kind, args, operation) {
     throw new Error(`${operation} requires at least one axis change.`);
   }
   if (Object.hasOwn(args, "angle")) validateAngle(args.angle);
-  if (Object.hasOwn(args, "line")) {
+  if (Object.hasOwn(args, "line") && args.line !== false) {
     validateObject(args.line, LINE_EDIT_OPTIONS, `${operation}.line`);
   }
-  if (Object.hasOwn(args, "ticks")) {
+  if (Object.hasOwn(args, "ticks") && args.ticks !== false) {
     validateObject(args.ticks, TICK_EDIT_OPTIONS, `${operation}.ticks`);
     validateModeOptions(args.ticks, `${operation}.ticks`);
   }
-  if (Object.hasOwn(args, "labels")) {
+  if (Object.hasOwn(args, "labels") && args.labels !== false) {
     validateObject(args.labels, LABEL_EDIT_OPTIONS, `${operation}.labels`);
     validateModeOptions(args.labels, `${operation}.labels`);
   }
-  if (Object.hasOwn(args, "ticksAndLabels")) {
+  if (args.ticksAndLabels !== undefined &&
+      (args.ticks !== undefined || args.labels !== undefined)) {
+    throw new Error(`${operation} cannot combine ticksAndLabels with ticks or labels.`);
+  }
+  if (Object.hasOwn(args, "ticksAndLabels") && args.ticksAndLabels !== false) {
     validateObject(
       args.ticksAndLabels,
       TICK_GROUP_OPTIONS,
       `${operation}.ticksAndLabels`
     );
     validateModeOptions(args.ticksAndLabels, `${operation}.ticksAndLabels`);
-    if (args.ticks !== undefined || args.labels !== undefined) {
-      throw new Error(
-        `${operation} cannot combine ticksAndLabels with ticks or labels.`
-      );
-    }
     if (args.ticksAndLabels.ticks !== undefined) {
       validateObject(
         args.ticksAndLabels.ticks,
@@ -156,7 +160,7 @@ function validateAxisEditArgs(kind, args, operation) {
       );
     }
   }
-  if (Object.hasOwn(args, "title")) {
+  if (Object.hasOwn(args, "title") && args.title !== false) {
     validateObject(
       args.title,
       kind === "theta"
@@ -167,6 +171,41 @@ function validateAxisEditArgs(kind, args, operation) {
   }
 }
 
+function applyAxisEdit(program, kind, args) {
+  const angleChanged = Object.hasOwn(args, "angle");
+  let next = angleChanged
+    ? program._withGuideConfig("radius", "layout", { angle: args.angle })
+    : program;
+  const edit = (component, options) => {
+    if (options === false) {
+      next = removeAxisComponent(next, kind, component);
+    } else if (options !== undefined || angleChanged && hasAxisComponent(next, kind, component)) {
+      next = next[`edit${prefix(kind)}Axis${component[0].toUpperCase() + component.slice(1)}`](options ?? {});
+    }
+  };
+  edit("line", args.line);
+  if (args.ticksAndLabels === false) {
+    edit("ticks", false);
+    edit("labels", false);
+  } else if (args.ticksAndLabels !== undefined) {
+    const group = args.ticksAndLabels;
+    const mode = {
+      ...(Object.hasOwn(group, "count") ? { count: group.count } : {}),
+      ...(Object.hasOwn(group, "values") ? { values: group.values } : {})
+    };
+    edit("ticks", { ...mode, ...(group.ticks ?? {}) });
+    edit("labels", { ...mode, ...(group.labels ?? {}) });
+  } else {
+    edit("ticks", args.ticks);
+    edit("labels", args.labels);
+  }
+  edit("title", args.title);
+  if (!AXIS_COMPONENTS.some(component => hasAxisComponent(next, kind, component))) {
+    next = next[`remove${prefix(kind)}Axis`]();
+  }
+  return next;
+}
+
 function makeEditAxis(kind) {
   const operation = `edit${prefix(kind)}Axis`;
   return action({
@@ -174,42 +213,18 @@ function makeEditAxis(kind) {
     description: `Edit selected Polar ${kind}-axis components.`
   }, function (args = {}) {
     validateAxisEditArgs(kind, args, operation);
-    const names = polarGuideNames(kind);
-    const angleChanged = Object.hasOwn(args, "angle");
-    let next = angleChanged
-      ? this._withGuideConfig("radius", "layout", { angle: args.angle })
-      : this;
-    const has = component =>
-      next.graphicSpec.objects[names[component]] !== undefined;
-    if (args.line !== undefined || (angleChanged && has("line"))) {
-      next = next[`edit${prefix(kind)}AxisLine`](args.line ?? {});
+    if (!AXIS_COMPONENTS.some(component => hasAxisComponent(this, kind, component))) {
+      throw new Error(`${operation} requires an existing ${kind}-axis component.`);
     }
-    if (args.ticksAndLabels !== undefined) {
-      const group = args.ticksAndLabels;
-      const mode = {
-        ...(Object.hasOwn(group, "count") ? { count: group.count } : {}),
-        ...(Object.hasOwn(group, "values") ? { values: group.values } : {})
-      };
-      next = next[`edit${prefix(kind)}AxisTicks`]({
-        ...mode,
-        ...(group.ticks ?? {})
-      });
-      next = next[`edit${prefix(kind)}AxisLabels`]({
-        ...mode,
-        ...(group.labels ?? {})
-      });
-    } else {
-      if (args.ticks !== undefined || (angleChanged && has("ticks"))) {
-        next = next[`edit${prefix(kind)}AxisTicks`](args.ticks ?? {});
+    for (const component of AXIS_COMPONENTS) {
+      if (args[component] === false ||
+          args.ticksAndLabels === false && ["ticks", "labels"].includes(component)) {
+        assertRemovableAxisComponent(this, kind, component, operation);
       }
-      if (args.labels !== undefined || (angleChanged && has("labels"))) {
-        next = next[`edit${prefix(kind)}AxisLabels`](args.labels ?? {});
-      }
-    }
-    if (args.title !== undefined || (angleChanged && has("title"))) {
-      next = next[`edit${prefix(kind)}AxisTitle`](args.title ?? {});
     }
-    return next;
+    // Validate the whole proposal on an immutable branch before returning changes.
+    applyAxisEdit(this, kind, args);
+    return applyAxisEdit(this, kind, args);
   });
 }
 

package/src/actions/guides/polar/axes/labels.js

@@ -26,11 +26,12 @@ import {
   prefix,
   resolveAngle,
   validateModeOptions,
+  validateComponentCreateArgs,
   validateObject,
   withAxisSemantics
 } from "./shared.js";
 
-function labelGeometry(program, kind, config) {
+function labelGeometry(program, kind, config, angle = resolveAngle(program, kind, {})) {
   const frame = resolvePolarFrameForProgram(program);
   const mapped = mapPolarGuideValues(program, config);
   const text = formatPolarGuideValues(program, config, mapped.values);
@@ -45,7 +46,7 @@ function labelGeometry(program, kind, config) {
         })
       : resolveRadialAxisLabels({
           frame,
-          angle: resolveAngle(program, kind, {}),
+          angle,
           radii: mapped.positions,
           offset: config.offset
         }))
@@ -171,7 +172,7 @@ function makeCreateLabels(kind) {
     op: operation.create,
     description: `Create the Polar ${kind}-axis labels.`
   }, function (args = {}) {
-    validateObject(args, LABEL_CREATE_OPTIONS, operation.create);
+    validateComponentCreateArgs(kind, args, LABEL_CREATE_OPTIONS, operation.create);
     validateModeOptions(args, operation.create);
     const names = polarGuideNames(kind);
     if (this.graphicSpec.objects[names.labels] !== undefined) {
@@ -180,7 +181,7 @@ function makeCreateLabels(kind) {
     const resources = componentResources(this, kind, args, operation.create);
     const angle = resolveAngle(this, kind, args);
     const config = resolveLabelConfig(this, kind, args, resources);
-    labelGeometry(this, kind, config);
+    labelGeometry(this, kind, config, angle);
     let next = withAxisSemantics(this, kind, resources);
     if (kind === "radius" &&
         next.guideConfigs.axis?.radius?.layout === undefined) {

package/src/actions/guides/polar/axes/lines.js

@@ -18,6 +18,7 @@ import {
   operations,
   prefix,
   resolveAngle,
+  validateComponentCreateArgs,
   validateObject,
   withAxisSemantics
 } from "./shared.js";
@@ -76,7 +77,7 @@ function makeCreateLine(kind) {
     op: operation.create,
     description: `Create the Polar ${kind}-axis baseline.`
   }, function (args = {}) {
-    validateObject(args, LINE_CREATE_OPTIONS, operation.create);
+    validateComponentCreateArgs(kind, args, LINE_CREATE_OPTIONS, operation.create);
     const names = polarGuideNames(kind);
     if (this.graphicSpec.objects[names.line] !== undefined) {
       throw new Error(`${operation.create} requires a missing axis line.`);

package/src/actions/guides/polar/axes/shared.js

@@ -48,6 +48,12 @@ export function validateObject(args, supported, operation) {
   validateOptionObject(args, supported, operation);
 }
 
+export function validateComponentCreateArgs(kind, args, supported, operation) {
+  validateObject(args, kind === "theta"
+    ? supported.filter(option => !["angle", "position"].includes(option))
+    : supported, operation);
+}
+
 export function validateModeOptions(args, operation) {
   if (Object.hasOwn(args, "count") && Object.hasOwn(args, "values")) {
     throw new Error(`${operation} cannot use count and values together.`);

package/src/actions/guides/polar/axes/ticks.js

@@ -23,11 +23,12 @@ import {
   TICK_CREATE_OPTIONS,
   TICK_EDIT_OPTIONS,
   validateModeOptions,
+  validateComponentCreateArgs,
   validateObject,
   withAxisSemantics
 } from "./shared.js";
 
-function tickGeometry(program, kind, config) {
+function tickGeometry(program, kind, config, angle = resolveAngle(program, kind, {})) {
   const frame = resolvePolarFrameForProgram(program);
   const mapped = mapPolarGuideValues(program, config);
   return {
@@ -40,7 +41,7 @@ function tickGeometry(program, kind, config) {
         })
       : resolveRadialAxisTicks({
           frame,
-          angle: resolveAngle(program, kind, {}),
+          angle,
           radii: mapped.positions,
           length: config.length
         }))
@@ -131,7 +132,7 @@ function makeCreateTicks(kind) {
     op: operation.create,
     description: `Create the Polar ${kind}-axis ticks.`
   }, function (args = {}) {
-    validateObject(args, TICK_CREATE_OPTIONS, operation.create);
+    validateComponentCreateArgs(kind, args, TICK_CREATE_OPTIONS, operation.create);
     validateModeOptions(args, operation.create);
     const names = polarGuideNames(kind);
     if (this.graphicSpec.objects[names.ticks] !== undefined) {
@@ -140,7 +141,7 @@ function makeCreateTicks(kind) {
     const resources = componentResources(this, kind, args, operation.create);
     const angle = resolveAngle(this, kind, args);
     const config = resolveTickConfig(this, kind, args, resources);
-    tickGeometry(this, kind, config);
+    tickGeometry(this, kind, config, angle);
     let next = withAxisSemantics(this, kind, resources);
     if (kind === "radius" &&
         next.guideConfigs.axis?.radius?.layout === undefined) {

package/src/actions/guides/polar/axes/titles.js

@@ -24,17 +24,18 @@ import {
   resolveAngle,
   TITLE_CREATE_OPTIONS,
   TITLE_EDIT_OPTIONS,
+  validateComponentCreateArgs,
   validateObject,
   withAxisSemantics
 } from "./shared.js";
 
-function titleGeometry(program, kind, config) {
+function titleGeometry(program, kind, config, angle = resolveAngle(program, kind, {})) {
   const frame = resolvePolarFrameForProgram(program);
   return kind === "theta"
     ? resolveThetaAxisTitle({ frame, offset: config.offset })
     : resolveRadialAxisTitle({
         frame,
-        angle: resolveAngle(program, kind, {}),
+        angle,
         offset: config.offset,
         position: config.position
       });
@@ -142,7 +143,7 @@ function makeCreateTitle(kind) {
     op: operation.create,
     description: `Create the Polar ${kind}-axis title.`
   }, function (args = {}) {
-    validateObject(args, TITLE_CREATE_OPTIONS, operation.create);
+    validateComponentCreateArgs(kind, args, TITLE_CREATE_OPTIONS, operation.create);
     const names = polarGuideNames(kind);
     if (this.graphicSpec.objects[names.title] !== undefined) {
       throw new Error(`${operation.create} requires a missing axis title.`);
@@ -154,7 +155,7 @@ function makeCreateTitle(kind) {
       args.text ?? inferAxisTitleText(this, names.channel, resources.scale),
       "Polar axis title text"
     );
-    const geometry = titleGeometry(this, kind, config);
+    const geometry = titleGeometry(this, kind, config, angle);
     validateTitleGeometry(this, kind, config, geometry, text);
     let next = withAxisSemantics(this, kind, resources);
     if (kind === "radius" &&

package/src/actions/guides/polar/grids.js

@@ -28,7 +28,7 @@ const EDIT_OPTIONS = Object.freeze([
   "count", "values", "color", "lineWidth", "strokeDash"
 ]);
 
-function operationNames(kind) {
+export function polarGridOperations(kind) {
   const prefix = kind === "theta" ? "Theta" : "Radial";
   return {
     create: `create${prefix}Grid`,
@@ -46,7 +46,7 @@ function validateStrokeDash(value) {
   }
 }
 
-function validateOptions(args, operation, create) {
+export function validatePolarGridOptions(args, operation, create) {
   validateOptionObject(
     args,
     create ? CREATE_OPTIONS : EDIT_OPTIONS,
@@ -154,7 +154,7 @@ function editConcrete(program, kind, config, geometry) {
 }
 
 function makeRematerialize(kind) {
-  const operations = operationNames(kind);
+  const operations = polarGridOperations(kind);
   return action({
     op: operations.rematerialize,
     description: `Recompute concrete Polar ${kind} grid geometry.`
@@ -181,12 +181,12 @@ function makeRematerialize(kind) {
 }
 
 function makeCreate(kind) {
-  const operations = operationNames(kind);
+  const operations = polarGridOperations(kind);
   return action({
     op: operations.create,
     description: `Create a semantic and concrete Polar ${kind} grid.`
   }, function (args = {}) {
-    validateOptions(args, operations.create, true);
+    validatePolarGridOptions(args, operations.create, true);
     const graphic = polarGuideNames(kind).grid;
     if (this.semanticSpec.guides.grid?.[kind] !== undefined ||
         this.graphicSpec.objects[graphic] !== undefined) {
@@ -222,12 +222,12 @@ function makeCreate(kind) {
 }
 
 function makeEdit(kind) {
-  const operations = operationNames(kind);
+  const operations = polarGridOperations(kind);
   return action({
     op: operations.edit,
     description: `Edit the existing Polar ${kind} grid.`
   }, function (args = {}) {
-    validateOptions(args, operations.edit, false);
+    validatePolarGridOptions(args, operations.edit, false);
     const previous = this.guideConfigs.grid?.[kind];
     if (previous === undefined) {
       throw new Error(`${operations.edit} requires an existing grid.`);

package/src/actions/guides/reuse.js

@@ -0,0 +1,44 @@
+import { isPlainObject } from "../../core/immutable.js";
+
+export function sameGuideValue(left, right) {
+  if (left === right) return true;
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every((value, i) => sameGuideValue(value, right[i]));
+  }
+  if (isPlainObject(left) && isPlainObject(right)) {
+    const keys = Object.keys(left);
+    return keys.length === Object.keys(right).length && keys.every(key =>
+      Object.hasOwn(right, key) && sameGuideValue(left[key], right[key])
+    );
+  }
+  return false;
+}
+
+export function guideConflict(label) {
+  throw new Error(`Facade guide conflict: ${label}. Use the existing guide editor or disable this facade's guide branch.`);
+}
+
+// Only explicit choices constrain existing appearance. Omitted defaults never
+// overwrite an earlier author's title, placement, or style.
+export function assertGuideOptions(requested, stored, label) {
+  for (const [key, value] of Object.entries(requested)) {
+    if (Array.isArray(value) && Array.isArray(stored?.[key]) && value.length === stored[key].length) {
+      assertGuideOptions(Object.fromEntries(value.entries()), Object.fromEntries(stored[key].entries()), `${label}.${key}`);
+    } else if (isPlainObject(value) && isPlainObject(stored?.[key])) {
+      assertGuideOptions(value, stored[key], `${label}.${key}`);
+    } else if (!sameGuideValue(value, stored?.[key])) {
+      guideConflict(`${label}.${key} differs from the existing guide`);
+    }
+  }
+}
+
+export function resolveStoredGuideCoordinate(program, guide, channel) {
+  if (guide.coordinate !== undefined) return guide.coordinate;
+  const ids = [...new Set(program.semanticSpec.layers.filter(layer =>
+    layer.encoding?.[channel]?.scale === guide.scale
+  ).map(layer => layer.coordinate).filter(id => id !== undefined))];
+  if (ids.length !== 1) {
+    guideConflict(`legacy ${channel} guide has no unique compatible coordinate`);
+  }
+  return ids[0];
+}

package/src/actions/guides/tickValues.js

@@ -19,29 +19,27 @@ export function inferHistogramBoundaries(program, channel, scaleId) {
       layer.encoding.x.bin !== undefined
   );
   if (consumers.length === 0) return undefined;
-  if (consumers.length > 1) {
-    throw new Error(
-      `Guide values cannot infer shared histogram bins for scale "${scaleId}".`
-    );
-  }
-
-  const [layer] = consumers;
-  const encoding = layer.encoding.x;
-  const dataset = findDataset(program, layer.data);
   const scale = findSemanticScale(program, scaleId);
-  if (dataset === undefined || scale === undefined) {
-    throw new Error(
-      `Guide values require histogram data and scale "${scaleId}".`
-    );
+  const boundaries = consumers.map(layer => {
+    const encoding = layer.encoding.x;
+    const dataset = findDataset(program, layer.data);
+    if (dataset === undefined || scale === undefined) {
+      throw new Error(`Guide values require histogram data and scale "${scaleId}".`);
+    }
+    return resolveHistogramBins({
+      values: readQuantitativeField(dataset.values, encoding.field),
+      bin: encoding.bin,
+      domain: scale.domain,
+      nice: scale.nice ?? true,
+      zero: scale.zero ?? false
+    }).boundaries;
+  });
+  const [unique] = boundaries;
+  if (boundaries.some(values => values.length !== unique.length ||
+    values.some((value, index) => value !== unique[index]))) {
+    throw new Error(`Guide values cannot infer shared histogram bins for scale "${scaleId}".`);
   }
-
-  return resolveHistogramBins({
-    values: readQuantitativeField(dataset.values, encoding.field),
-    bin: encoding.bin,
-    domain: scale.domain,
-    nice: scale.nice ?? true,
-    zero: scale.zero ?? false
-  }).boundaries;
+  return unique;
 }
 
 export function valuesFromTickConfig(program, config) {

package/src/actions/index.js

@@ -18,8 +18,10 @@ import { registerRegressionActions } from "./regression/index.js";
 import { registerViolinPlotActions } from "./violinPlots/index.js";
 import { registerErrorBandActions } from "./errorBands/index.js";
 import { registerChartActions } from "./charts/index.js";
+import { registerThemeActions } from "./theme/index.js";
 
 export function registerActions(ProgramClass) {
+  registerThemeActions(ProgramClass);
   registerPrimitiveActions(ProgramClass);
   registerCompositionActions(ProgramClass);
   registerFacetActions(ProgramClass);

package/src/actions/intervals/resolve.js

@@ -7,15 +7,15 @@ import {
   validateNonEmptyString as requireField,
   validateOptionObject
 } from "../../core/validation.js";
-import { readQuantitativeField } from "../../grammar/scales/index.js";
+import { readQuantitativeField, resolveTemporalUnit } from "../../grammar/scales/index.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { hasLayer, resolveEligibleLayer } from "../../selectors/layers.js";
 import { findSemanticScale } from "../../selectors/scales.js";
 
 const CHANNEL_OPTIONS = [
-  "field", "fieldType", "scale", "center", "extent", "level", "lower", "upper"
+  "field", "fieldType", "scale", "center", "extent", "method", "level", "lower", "upper", "temporalUnit"
 ];
-const INTERVAL_PARAMETER_KEYS = CHANNEL_OPTIONS.slice(3);
+const INTERVAL_PARAMETER_KEYS = ["center", "extent", "method", "level", "lower", "upper"];
 const POSITION_CHANNELS = ["x", "y"];
 const FIELD_TYPES = [
   "quantitative", "temporal", "ordinal", "nominal"
@@ -71,7 +71,7 @@ function resolveIntervalChannel(channels, sourceLayer, {
 }) {
   for (const hints of [
     ["lower", "upper"],
-    ["center", "extent", "level"]
+    ["center", "extent", "method", "level"]
   ]) {
     const hinted = POSITION_CHANNELS.filter(channel =>
       hasAny(channels[channel], hints)
@@ -123,8 +123,10 @@ function resolvePosition(program, channel, explicit, inferred, {
       `${operation} ${channel} position requires ${positionTypes.join(", ")} field type.`
     );
   }
+  const temporalUnit = resolveTemporalUnit({ ...explicit, field: explicit?.field ?? inferred?.field }, fieldType, inferred);
   return {
     channel,
+    ...(temporalUnit === undefined ? {} : { temporalUnit }),
     field: requireField(
       explicit?.field ?? inferred?.field,
       `${operation} ${channel} field`
@@ -143,6 +145,9 @@ function resolveInterval(program, channel, explicit, inferred, dataset, {
   operation,
   intervalScaleDefaults
 }) {
+  if (Object.hasOwn(explicit ?? {}, "temporalUnit")) {
+    throw new Error(`${operation} ${channel} interval does not accept temporalUnit.`);
+  }
   if (explicit?.fieldType !== undefined) {
     throw new Error(`${operation} ${channel} interval does not accept fieldType.`);
   }
@@ -167,10 +172,11 @@ function resolveInterval(program, channel, explicit, inferred, dataset, {
     if (
       explicit.field !== undefined ||
       explicit.extent !== undefined ||
+      explicit.method !== undefined ||
       explicit.level !== undefined
     ) {
       throw new Error(
-        `Explicit ${operation} ${channel} interval cannot combine field, extent, or level.`
+        `Explicit ${operation} ${channel} interval cannot combine field, extent, method, or level.`
       );
     }
     const fields = {
@@ -187,15 +193,22 @@ function resolveInterval(program, channel, explicit, inferred, dataset, {
     }
     return { channel, mode: "explicit", fields, scale, title: fields.center };
   }
+  const field = requireField(
+    explicit?.field ?? inferred?.field,
+    `${operation} ${channel} field`
+  );
+  if (!dataset.values.some(row => Number.isFinite(row?.[field]))) {
+    throw new TypeError(
+      `Field "${field}" must contain at least one finite number.`
+    );
+  }
   return {
     channel,
     mode: "statistical",
-    field: requireField(
-      explicit?.field ?? inferred?.field,
-      `${operation} ${channel} field`
-    ),
+    field,
     center: explicit?.center,
     extent: explicit?.extent,
+    method: explicit?.method,
     level: explicit?.level,
     scale
   };
@@ -205,11 +218,16 @@ function resolveGrouping(args, sourceLayer, independentField, mode, {
   operation,
   allowExplicitGrouping
 }) {
-  if (mode === "explicit" && !allowExplicitGrouping && args.groupBy !== undefined) {
+  if (
+    mode === "explicit" &&
+    !allowExplicitGrouping &&
+    args.groupBy !== undefined &&
+    args.groupBy !== false
+  ) {
     throw new Error(`Explicit ${operation} intervals do not accept groupBy.`);
   }
   const inferred = sourceLayer?.encoding?.group?.field;
-  const groupField = args.groupBy ?? inferred;
+  const groupField = args.groupBy === false ? undefined : args.groupBy ?? inferred;
   const normalizedGroup = groupField === undefined
     ? undefined
     : requireField(groupField, `${operation} groupBy`);
@@ -234,7 +252,9 @@ export function resolveIntervalComposite(program, args, policy) {
       : requireObject(args.y, `${operation} y`)
   };
   let sourceLayer;
-  if (!(args.target === undefined && args.x !== undefined && args.y !== undefined)) {
+  if (policy.existingId === undefined && !(
+    args.target === undefined && args.x !== undefined && args.y !== undefined
+  )) {
     const target = args.target === undefined
       ? undefined
       : validateUserId(args.target, `${operation} source layer id`);
@@ -281,7 +301,7 @@ export function resolveIntervalComposite(program, args, policy) {
     policy
   );
   const defaultId = policy.defaultId;
-  const id = resolveOptionalUserId(args.id, {
+  const id = policy.existingId ?? resolveOptionalUserId(args.id, {
     defaultId,
     label: policy.ownerLabel,
     operation,
@@ -289,7 +309,7 @@ export function resolveIntervalComposite(program, args, policy) {
       program.graphicSpec.objects[defaultId] !== undefined ||
       findDataset(program, `${defaultId}IntervalData`) !== undefined
   });
-  const generatedFields = {
+  const generatedFields = policy.generatedFields ?? {
     center: `__${id}_center`,
     lower: `__${id}_lower`,
     upper: `__${id}_upper`
@@ -309,7 +329,7 @@ export function resolveIntervalComposite(program, args, policy) {
     source: dataset.id,
     dataId: interval.mode === "statistical" ? `${id}IntervalData` : dataset.id,
     coordinate: validateUserId(
-      args.coordinate ?? sourceLayer?.coordinate ?? "main",
+      args.coordinate ?? policy.coordinate ?? sourceLayer?.coordinate ?? "main",
       `${resourceLabel} coordinate id`
     ),
     orientation: intervalChannel === "y" ? "vertical" : "horizontal",