ggaction 0.0.20 → 0.0.22

package/src/actions/marks/text/actions.js

@@ -1,9 +1,11 @@
+import { materializeMarkClip } from "../../../materialization/markClip.js";
+import { requestedMarkClip, validateMarkClipCoordinate } from "../../../selectors/markClip.js";
 import { TEXT_LABEL_LAYOUT_OPTIONS } from "./layout.js";
 import { action } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
 import {
   DEFAULT_TEXT_MARK,
-  TEXT_MARK_STYLE_OPTIONS as STYLE_OPTIONS,
+  TEXT_MARK_STYLE_OPTIONS,
   isSourceOwnedText,
   normalizeTextMarkConfig
 } from "../../../grammar/text.js";
@@ -42,6 +44,7 @@ import { resolveMarkGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
 import { validateItemMissing } from "../../../grammar/itemMissing.js";
 
+const STYLE_OPTIONS = Object.freeze(["clip", ...TEXT_MARK_STYLE_OPTIONS]);
 const CREATE_OPTIONS = Object.freeze(["id", "data", "source", "text", "missing", ...STYLE_OPTIONS]);
 const EDIT_OPTIONS = Object.freeze(["target", "missing", ...STYLE_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id", "replayLayout"]);
@@ -130,6 +133,7 @@ const createTextMark = /* @__PURE__ */ action(
   },
   function (args = {}) {
     validateMarkOptions(args, CREATE_OPTIONS, "createTextMark");
+    requestedMarkClip(args);
     const id = resolveMarkId(this, args.id, {
       defaultId: "text",
       label: "Text mark id",
@@ -456,7 +460,7 @@ const rematerializeTextMark = /* @__PURE__ */ action(
           ? next
           : next.materializeMarkLabelPlacement({ id });
     }
-    let next = this.editGraphics({
+    let next = materializeMarkClip(this.editGraphics({
       target: id,
       property: "items",
       value: resolveTextGraphicItems(
@@ -464,7 +468,7 @@ const rematerializeTextMark = /* @__PURE__ */ action(
         layer,
         this.markConfigs[id] ?? DEFAULT_TEXT_MARK
       )
-    });
+    }), id);
     if (replayLayout && next.materializationConfigs.labelLayouts?.[id] !== undefined) {
       return next.materializeLabelLayout({ id, rematerializeBase: false });
     }
@@ -481,6 +485,7 @@ const editTextMark = /* @__PURE__ */ action(
   },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editTextMark");
+    requestedMarkClip(args);
     if (!["missing", ...STYLE_OPTIONS].some(option => Object.hasOwn(args, option))) {
       throw new Error("editTextMark requires at least one editable property.");
     }
@@ -494,6 +499,7 @@ const editTextMark = /* @__PURE__ */ action(
     if (Object.hasOwn(args, "fill") && layer.encoding?.color !== undefined) {
       throw new Error("Text fill conflicts with its color encoding.");
     }
+    validateMarkClipCoordinate(this, layer, args.clip ?? this.markConfigs[layer.id]?.clip);
     const semantic = Object.hasOwn(args, "missing")
       ? this.editSemantic({
           property: `layer[${layer.id}].mark.missing`,
@@ -507,6 +513,7 @@ const editTextMark = /* @__PURE__ */ action(
           args,
           semantic.markConfigs[layer.id] ?? DEFAULT_TEXT_MARK
         ),
+        ...requestedMarkClip(args),
         fillExplicit: Object.hasOwn(args, "fill")
           ? true
           : semantic.markConfigs[layer.id]?.fillExplicit ?? false

package/src/actions/marks/tick/actions.js

@@ -1,3 +1,4 @@
+import { requestedMarkClip, validateMarkClipCoordinate } from "../../../selectors/markClip.js";
 import { action } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
 import {
@@ -15,6 +16,7 @@ import { resolveMarkGraphicPlacement } from
 import { resolveRowEncodingValues } from
   "../../../materialization/rowEncoding.js";
 import { findDataset } from "../../../selectors/datasets.js";
+import { validateTickColorChannels } from "../../../grammar/scales/colorConsumers.js";
 import { findLayer } from "../../../selectors/layers.js";
 import { DEFAULT_COLORS } from "../../../theme/defaults.js";
 import {
@@ -37,7 +39,7 @@ import {
 } from "../shared.js";
 
 const APPEARANCE_OPTIONS = Object.freeze([
-  "length", "stroke", "strokeWidth", "opacity", ...STROKE_STYLE_PROPERTIES
+  "clip", "length", "stroke", "strokeWidth", "opacity", ...STROKE_STYLE_PROPERTIES
 ]);
 const CREATE_OPTIONS = Object.freeze(["id", "data", "missing", ...APPEARANCE_OPTIONS]);
 const EDIT_OPTIONS = Object.freeze(["target", "missing", ...APPEARANCE_OPTIONS]);
@@ -74,6 +76,7 @@ function resolveTick(program, requested, operation) {
 function validateTickConfig(args, current = DEFAULT_TICK_CONFIG) {
   return {
     ...current,
+    ...requestedMarkClip(args),
     length: Object.hasOwn(args, "length")
       ? validatePositiveFinite(args.length, "Tick length")
       : current.length,
@@ -97,6 +100,7 @@ export const createTickMark = /* @__PURE__ */ action(
   },
   function (args = {}) {
     validateMarkOptions(args, CREATE_OPTIONS, "createTickMark");
+    requestedMarkClip(args);
     requestedStrokeDetails(args, "createTickMark");
     const id = resolveMarkId(this, args.id, {
       defaultId: "tick",
@@ -148,6 +152,7 @@ export const editTickMark = /* @__PURE__ */ action(
   },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editTickMark");
+    requestedMarkClip(args);
     requestedStrokeDetails(args, "editTickMark");
     if (!["missing", ...APPEARANCE_OPTIONS].some(property => Object.hasOwn(args, property))) {
       throw new Error(
@@ -155,11 +160,13 @@ export const editTickMark = /* @__PURE__ */ action(
       );
     }
     const layer = resolveTick(this, args.target, "editTickMark");
+    if (Object.hasOwn(args, "stroke")) validateTickColorChannels(layer, "stroke");
     if (Object.hasOwn(args, "stroke") && layer.encoding?.stroke !== undefined) {
       throw new Error(
         "editTickMark stroke conflicts with a field encoding; use encodeStroke with value to replace it."
       );
     }
+    validateMarkClipCoordinate(this, layer, args.clip ?? this.markConfigs[layer.id]?.clip);
     const semantic = Object.hasOwn(args, "missing")
       ? this.editSemantic({
           property: `layer[${layer.id}].mark.missing`,
@@ -200,6 +207,7 @@ export const rematerializeTickMark = /* @__PURE__ */ action(
     if (layer?.mark?.type !== "tick") {
       throw new Error(`Unknown tick mark "${id}".`);
     }
+    validateTickColorChannels(layer);
     const graphic = this.graphicSpec.objects[id];
     if (graphic?.type !== "line" || !Array.isArray(graphic.items)) {
       throw new Error(`Tick mark "${id}" requires line collection graphics.`);
@@ -220,7 +228,8 @@ export const rematerializeTickMark = /* @__PURE__ */ action(
 
     const x = resolveRowEncodingValues(this, layer, dataset, "x");
     const y = resolveRowEncodingValues(this, layer, dataset, "y");
-    const stroke = resolveRowEncodingValues(this, layer, dataset, "stroke");
+    const stroke = resolveRowEncodingValues(this, layer, dataset,
+      layer.encoding?.color === undefined ? "stroke" : "color");
     const angles = resolveDirectionValues(dataset.values, layer.encoding?.angle);
     const config = validateTickConfig({}, {
       ...DEFAULT_TICK_CONFIG,

package/src/actions/primitives/editGraphics.js

@@ -1,3 +1,4 @@
+import { validateGraphicClip } from "../../grammar/schemas/graphicClip.js";
 import { validateGraphicItemLimit } from "../../core/validation.js";
 import { closedAction } from "../../core/action.js";
 import { cloneAndFreeze, freezeOwned, isPlainObject } from "../../core/immutable.js";
@@ -13,7 +14,8 @@ import { validateConcreteGraphicValue } from
 import {
   collectGraphicSubtreeIds,
   findGraphicParent,
-  requireGraphic
+  requireGraphic,
+  resolveGraphicChildOrder
 } from "../../grammar/schemas/graphicTree.js";
 
 function setGraphicProperty(properties, property, value) {
@@ -96,6 +98,7 @@ function editGeneratedItem(owner, itemIndex, property, value) {
   const type = item.type ?? owner.type;
   validateGraphicProperty(type, property);
   validateConcreteGraphicValue(type, property, value);
+  if (Object.is(item.properties[property], value)) return owner;
   items[itemIndex] = freezeOwned({
     ...item,
     properties: setGraphicProperty(item.properties, property, value)
@@ -126,17 +129,20 @@ function editItems(owner, property, value, id, program) {
       `${owner.type}.${property} requires ${owner.items.length} values, received ${value.length}.`
     );
   }
+  let changed = false;
   const items = owner.items.map((item, index) => {
     const itemValue = Array.isArray(value) ? value[index] : value;
     const type = item.type ?? owner.type;
     validateGraphicProperty(type, property);
     validateConcreteGraphicValue(type, property, itemValue);
+    if (Object.is(item.properties[property], itemValue)) return item;
+    changed = true;
     return freezeOwned({
       ...item,
       properties: setGraphicProperty(item.properties, property, itemValue)
     });
   });
-  return freezeOwned({ ...owner, items: freezeOwned(items) });
+  return changed ? freezeOwned({ ...owner, items: freezeOwned(items) }) : owner;
 }
 
 function removeGraphicTree(graphicSpec, id) {
@@ -188,11 +194,27 @@ const editGraphics = /* @__PURE__ */ closedAction(
       return this._clone({ graphicSpec: removeGraphicTree(this.graphicSpec, found.id) });
     }
 
+    if (property === "children") {
+      const children = freezeOwned(resolveGraphicChildOrder(this.graphicSpec, target, value));
+      const updated = freezeOwned({ ...found.object, children });
+      return this._clone({ graphicSpec: freezeOwned({ ...this.graphicSpec,
+        objects: freezeOwned({ ...this.graphicSpec.objects, [target]: updated }) }) });
+    }
+
     const ownerId = found.kind === "item" ? found.ownerId : found.id;
     const owner = found.kind === "item" ? found.owner : found.object;
     if (owner.items !== undefined) validateGraphicItemLimit(owner.items.length, resolveGraphicItemCapacity(this, {
       id: ownerId, label: "Graphic collection length"
     }));
+    if (property === "clip") {
+      if (found.kind !== "object") throw new Error("Graphic clip requires a named owner, not a generated item.");
+      if (owner.type === "canvas") validateGraphicClip(value, owner.type);
+      if (value !== false) validateGraphicClip(value, owner.type);
+      const {clip: previous, ...rest} = owner;
+      const updated = value === false ? freezeOwned(rest) : freezeOwned({...rest, clip: cloneAndFreeze(value)});
+      return this._clone({graphicSpec: freezeOwned({...this.graphicSpec,
+        objects: freezeOwned({...this.graphicSpec.objects, [ownerId]: updated})})});
+    }
     const replacesDrawableItems =
       found.kind === "object" && property === "items" &&
       owner.items !== undefined && owner.type !== "collection";
@@ -203,7 +225,8 @@ const editGraphics = /* @__PURE__ */ closedAction(
           : owner.type, property);
     let updated;
     if (replacesDrawableItems) {
-      updated = replaceDrawableItems(value, ownerId, owner.type, this);
+      updated = freezeOwned({...replaceDrawableItems(value, ownerId, owner.type, this),
+        ...(owner.clip === undefined ? {} : {clip: owner.clip})});
     } else if (found.kind === "item") {
       if (validatedProperty === "length" || validatedProperty === "items") {
         throw new Error(`${validatedProperty} can only target an owning graphic.`);
@@ -224,6 +247,7 @@ const editGraphics = /* @__PURE__ */ closedAction(
       validateGraphicItemLimit(value, resolveGraphicItemCapacity(this, { id: ownerId, label: "Graphic collection length" }));
       updated = freezeOwned({
         type: owner.type,
+        ...(owner.clip === undefined ? {} : {clip: owner.clip}),
         items: freezeOwned(Array.from({ length: value }, (_, index) => freezeOwned({
           id: `${ownerId}:${index}`,
           properties: index === 0 ? owner.properties : freezeOwned({})
@@ -236,6 +260,7 @@ const editGraphics = /* @__PURE__ */ closedAction(
         properties: setGraphicProperty(owner.properties, validatedProperty, value)
       });
     }
+    if (updated === owner) return this;
     return this._clone({
       graphicSpec: freezeOwned({
         ...this.graphicSpec,

package/src/actions/primitives/index.js

@@ -1,6 +1,8 @@
 import { createSemanticValueValidator } from "./semanticValidation/index.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validateBin2DTransform } from "../../grammar/bin2d.js";
+import { validateFlattenTransform } from "../../grammar/flatten.js";
+import {validateLookupTransform} from "../../grammar/lookup.js";
 import { registerSemanticPrimitiveAction } from "./semantic.js";
 import { registerEditGraphicsAction } from "./editGraphics.js";
 import { registerCreateGraphicsAction } from "./createGraphics.js";
@@ -12,6 +14,13 @@ function validateBasicDatasetTransforms(value) {
       "Dataset transform must contain exactly one plain object."
     );
   }
+  if (value[0].type === "flatten") {
+    validateFlattenTransform(value[0]);
+    return;
+  }
+  if(value[0].type==="lookup"){
+    validateLookupTransform(value[0]);return;
+  }
   if (value[0].type !== "bin2d") {
     throw new Error(`Unsupported dataset transform "${value[0].type}".`);
   }

package/src/actions/primitives/semanticAction.js

@@ -7,7 +7,7 @@ import {
   removeOwnedPath
 } from "../../core/immutable.js";
 import { parseSemanticPath } from "../../grammar/schemas/semanticPath.js";
-import { deriveTransformSchema, inferDatasetSchema, validateRowsAgainstSchema } from "../../grammar/datasetSchema.js";
+import { deriveTransformSchema, inferDatasetSchema, validateRowsAgainstSchema,datasetSchemaContext } from "../../grammar/datasetSchema.js";
 
 
 const CONTEXT_KEYS = Object.freeze({
@@ -57,7 +57,7 @@ function updateEntity(spec, parsed, value) {
         source.schema,
         value[0],
         undefined,
-        { sourceId: source.id, ownerId: parsed.id, sourceTransform: source.transform?.[0] }
+        datasetSchemaContext(source,value[0],parsed.id,id=>collection.find(d=>d.id===id))
       ));
     }
   }
@@ -70,11 +70,8 @@ function updateEntity(spec, parsed, value) {
       ? undefined
       : collection.find(dataset => dataset.id === current.source);
     const schema = source?.schema !== undefined && current.transform?.length === 1
-      ? deriveTransformSchema(source.schema, current.transform[0], value, {
-          sourceId: source.id,
-          sourceTransform: source.transform?.[0],
-          ownerId: parsed.id
-        })
+      ? deriveTransformSchema(source.schema, current.transform[0], value,
+          datasetSchemaContext(source,current.transform[0],parsed.id,id=>collection.find(d=>d.id===id)))
       : inferDatasetSchema(value);
     validateRowsAgainstSchema(value, schema, `Dataset "${parsed.id}"`);
     updated = setNestedProperty(updated, ["schema"], schema);
@@ -207,6 +204,15 @@ export function withRematerializedDerivedDataset(program, {
 // replaying their canonical primitive owners. Keep that speculative clone in
 // the primitive boundary and preserve the caller's layer for later dependency
 // and guide reconciliation.
+export function withPreviewLayerEncodings(program, { id, encodings }) {
+  return program._clone({ semanticSpec: {
+    ...program.semanticSpec,
+    layers: program.semanticSpec.layers.map(layer => layer.id === id
+      ? { ...layer, encoding: { ...layer.encoding, ...encodings } }
+      : layer)
+  } });
+}
+
 export function withoutPreviewLayerEncodings(program, { id, channels }) {
   const removed = new Set(channels);
   const semanticSpec = {

package/src/actions/primitives/semanticValidation/layer.js

@@ -21,6 +21,8 @@ import { normalizeStatisticalWeight } from
   "../../../grammar/weightedStatistics.js";
 import { ITEM_MISSING_MARK_TYPES, validateItemMissing } from
   "../../../grammar/itemMissing.js";
+import { isIndependentText, validateTextOffsetEncoding } from "../../../grammar/text.js";
+import { validateLineMissing, validateLineMissingScope } from "../../../grammar/lineMissing.js";
 
 function validateLayerSource(program, parsed, value, sourceMarkTypes) {
   validateUserId(value, "Layer source id");
@@ -51,6 +53,20 @@ export function validateLayerSemanticValue(
   } = {}
 ) {
   const property = parsed.path.join(".");
+  if (/^encoding\.(dx|dy)(\.|$)/.test(property)) {
+    if (!isIndependentText(findLayer(program, parsed.id))) {
+      throw new Error("Numeric text offsets require independent Text marks.");
+    }
+    const channel = parsed.path[1];
+    if (parsed.path.length === 2) validateTextOffsetEncoding(value, channel);
+    else if (property.endsWith(".fieldType") && value !== "quantitative") {
+      throw new Error(`Text ${channel} field type must be quantitative.`);
+    } else if (property.endsWith(".datum") && !Number.isFinite(value)) {
+      throw new TypeError(`Text ${channel} datum must be finite logical pixels.`);
+    } else if (property.endsWith(".field")) {
+      validateNonEmptySemanticString(value, `Text ${channel} field`);
+    }
+  }
   if (property === "mark.type" && !MARK_TYPES.includes(value)) {
     throw new Error(`Unknown mark type "${value}".`);
   }
@@ -60,6 +76,10 @@ export function validateLayerSemanticValue(
       if (!["error", "break"].includes(value)) {
         throw new Error(`Unsupported area missing policy "${value}".`);
       }
+    } else if (markType === "line") {
+      validateLineMissing(value);
+      const layer = findLayer(program, parsed.id);
+      validateLineMissingScope({ ...layer, mark: { ...layer.mark, missing: value } });
     } else if (ITEM_MISSING_MARK_TYPES.includes(markType)) {
       validateItemMissing(value, `${markType} missing`);
     } else {

package/src/actions/primitives/semanticValidation/scale.js

@@ -8,6 +8,7 @@ import {
   validateSemanticScaleType
 } from "../../../grammar/scales/index.js";
 import { findSemanticScale } from "../../../selectors/scales.js";
+import { normalizeScaleNice } from "../../../grammar/scales/continuous.js";
 import { findScaleConsumers } from "../../scales/consumers/index.js";
 
 function isOffsetScale(program, id, existing) {
@@ -51,6 +52,7 @@ export function validateScaleSemanticValue(program, parsed, value) {
         ["paddingInner", "paddingOuter", "align"].includes(owned)
       ) continue;
       validateScalePropertyForType(value, owned);
+      if (owned === "nice") normalizeScaleNice(value, existing[owned]);
     }
     return;
   }
@@ -62,7 +64,12 @@ export function validateScaleSemanticValue(program, parsed, value) {
     return;
   }
   if (property === "range") return validateSemanticScaleRange(value);
-  if (["nice", "zero", "clamp", "reverse"].includes(property)) {
+  if (property === "nice") {
+    normalizeScaleNice(existing?.type, value);
+    validateOwnedProperty(program, parsed.id, existing, property);
+    return;
+  }
+  if (["zero", "clamp", "reverse"].includes(property)) {
     if (typeof value !== "boolean") {
       throw new TypeError(`Scale ${property} must be a boolean.`);
     }

package/src/actions/scales/channels.js

@@ -79,7 +79,7 @@ const DEFINITIONS = Object.freeze({
   }),
   editStrokeDashScale: Object.freeze({
     channel: "strokeDash",
-    options: Object.freeze(["type", "domain", "range", "emptyDomain"])
+    options: Object.freeze(["type", "domain", "range", "emptyDomain", "unknown"])
   })
 });
 

package/src/actions/scales/consumers/common.js

@@ -1,7 +1,10 @@
 import { isSourceOwnedText } from "../../../grammar/text.js";
 import { readSeriesIdentity, validatePathSeriesAppearance } from "../../../grammar/pathSeries.js";
 import { readAreaEndpoint } from "../../../grammar/areaEndpoints.js";
-import { readScaleField } from "../../../grammar/scales/index.js";
+import { readLinePosition } from "../../../grammar/lineMissing.js";
+import { readNominalField, readScaleField } from "../../../grammar/scales/index.js";
+import { readCategoricalLineColor, validateCategoricalColorConsumer } from "../../../grammar/scales/colorConsumers.js";
+import { readArcColorValues } from "../../../grammar/arcs.js";
 import { findDataset } from "../../../selectors/datasets.js";
 import { requireSemanticScale } from "../../../selectors/scales.js";
 import { SCALED_ENCODING_CHANNELS } from "../../../core/vocabulary.js";
@@ -56,6 +59,21 @@ export function readConsumerFieldValues(
   scale = findScale(program, consumer.encoding.scale)
 ) {
   const { field, fieldType, temporalUnit } = consumer.encoding;
+  if (consumer.layer.mark.type === "line" && consumer.layer.mark.missing === "break" &&
+      ["x", "y"].includes(consumer.channel)) {
+    return readLinePosition(dataset.values, consumer.encoding).filter(value => value !== null);
+  }
+  if (consumer.channel === "strokeDash") {
+    validateCategoricalColorConsumer(consumer.layer, consumer.encoding, scale, "strokeDash");
+    return readNominalField(dataset.values, field);
+  }
+  if (consumer.channel === "color" && ["nominal", "ordinal"].includes(fieldType) &&
+      validateCategoricalColorConsumer(consumer.layer, consumer.encoding, scale)) {
+    return readCategoricalLineColor(dataset.values, field);
+  }
+  if (consumer.layer.mark.type === "arc" && consumer.channel === "color") {
+    return readArcColorValues(dataset.values, consumer.layer);
+  }
   if (consumer.layer.mark.type === "bar" && consumer.layer.encoding?.group !== undefined && ["xOffset", "yOffset"].includes(consumer.channel)) {
     return readSeriesIdentity(dataset.values, consumer.layer).values;
   }

package/src/actions/scales/consumers/families.js

@@ -19,13 +19,13 @@ import { findScale } from "./common.js";
 
 function lineDerivationOptions(program, consumer, dataset) {
   const x = consumer.layer.encoding?.x;
-  if (x?.bin === undefined) return undefined;
+  if (x?.bin === undefined) return { scales: program.semanticSpec.scales };
   const bins = resolveLineBins(
     dataset.values,
     consumer.layer,
     findScale(program, x.scale)
   );
-  return { xBinBoundaries: bins.boundaries };
+  return { xBinBoundaries: bins.boundaries, scales: program.semanticSpec.scales };
 }
 
 export function resolveMarkFamilyConsumerValues(program, consumer, dataset) {

package/src/actions/scales/consumers/seriesLayout.js

@@ -1,3 +1,4 @@
+import { applyItemMissingPolicy } from "../../../grammar/itemMissing.js";
 import { readSeriesIdentity } from "../../../grammar/pathSeries.js";
 import { deriveAreaSeries } from "../../../grammar/areaSeries.js";
 import { deriveBarAggregates } from "../../../grammar/bars/aggregate.js";
@@ -44,7 +45,7 @@ export function resolveHistogramCountValues(program, consumer) {
       `Histogram mark "${consumer.layer.id}" requires an existing dataset.`
     );
   }
-  const input = resolveHistogramInput(dataset, xEncoding);
+  const input = resolveHistogramInput(dataset, xEncoding, consumer.layer.encoding.y);
   const xValues = input.values;
   const bins = resolveHistogramBins({
     values: xValues,
@@ -63,10 +64,10 @@ export function resolveHistogramCountValues(program, consumer) {
 
 function resolveHistogramPartitions(program, consumer) {
   const layer = consumer.layer;
-  const dataset = findDataset(program, layer.data);
+  const dataset = applyItemMissingPolicy(layer, findDataset(program, layer.data));
   const xEncoding = layer.encoding.x;
   const xScale = findScale(program, xEncoding.scale);
-  const input = resolveHistogramInput(dataset, xEncoding);
+  const input = resolveHistogramInput(dataset, xEncoding, consumer.layer.encoding.y);
   const xValues = input.values;
   const bins = resolveHistogramBins({
     values: xValues,

package/src/actions/scales/edit.js

@@ -35,6 +35,17 @@ const EDITABLE = Object.freeze(
 );
 const REQUESTED_CHANGES = Object.freeze(OPTIONS.filter(option => option !== "id"));
 
+// Encoding assignment reuses the wrapped owner without exposing Full editors in Basic.
+export function editScaleForEncoding(program, args) {
+  const available = program.editScale;
+  if (typeof available === "function") return available.call(program, args);
+  const existing = requireSemanticScale(program, args.id);
+  if (args.type !== undefined && args.type !== existing.type) {
+    throw new Error("Color scale type transitions require the Full ChartProgram; use a new scale id in Basic.");
+  }
+  return editScale.call(program, args);
+}
+
 function resolveScaleId(program, requested) {
   if (requested !== undefined) {
     const id = validateUserId(requested, "Scale id");

package/src/actions/scales/editPolicy.js

@@ -1,4 +1,4 @@
-import { validateContinuousColorConsumer } from "../../grammar/scales/colorConsumers.js";
+import { validateCategoricalColorConsumer, validateContinuousColorConsumer } from "../../grammar/scales/colorConsumers.js";
 import {
   hasOrdinalDomain,
   isContinuousColorScaleType,
@@ -249,8 +249,10 @@ function normalizeDefinition(program, scale, channel, consumers, patch) {
     ? normalizedPatch.unknown
     : typeChanged ? undefined : scale.unknown;
   if (unknown !== undefined) {
-    if (consumers.some(consumer => consumer.layer.mark?.type !== "point")) {
-      throw new Error("Scale unknown currently requires row-owned point consumers.");
+    for (const consumer of consumers) {
+      if (consumer.layer.mark?.type !== "point") {
+        validateCategoricalColorConsumer(consumer.layer, consumer.encoding, { ...definition, unknown }, consumer.channel);
+      }
     }
     definition.unknown = consumers.length === 0
       ? unknown

package/src/actions/scales/preview.js

@@ -42,7 +42,8 @@ function resolveScalePreviewAtBounds(program, id, bounds) {
   const valuesByConsumer = consumers.map(consumer => {
     if (
       program.markConfigs?.[consumer.layer.id]?.markFilter?.empty === true ||
-      program.markConfigs?.[consumer.layer.id]?.statisticalReference !== undefined
+      (program.markConfigs?.[consumer.layer.id]?.statisticalReference !== undefined &&
+        ["x", "y", "x2", "y2"].includes(consumer.channel))
     ) {
       return {
         consumer,

package/src/actions/scales/quantitativeColor.js

@@ -1,3 +1,4 @@
+import { editScaleForEncoding } from "./edit.js";
 import { closedAction } from "../../core/action.js";
 
 import { findSemanticScale } from "../../selectors/scales.js";
@@ -24,10 +25,7 @@ export const setQuantitativeColorScale = /* @__PURE__ */ closedAction(
     }
     const existing = findSemanticScale(this, args.id);
     if (existing !== undefined && existing.type !== args.type) {
-      if (typeof this.editScale !== "function") {
-        throw new Error("Color scale type transitions require the Full ChartProgram; use a new scale id in Basic.");
-      }
-      return this.editScale(args);
+      return editScaleForEncoding(this, args);
     }
     let next = this;
     for (const property of ["whitePoint", "gamma"]) {

package/src/actions/selection/actions.js

@@ -1,7 +1,8 @@
 import { action, closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { isPlainObject } from "../../core/immutable.js";
-import { validateKeys } from "../../core/validation.js";
+import { validateKeys, validateWorkLimit } from "../../core/validation.js";
+import { validatePointShape } from "../../grammar/pointShapes.js";
 import { collectResourceReferences } from "../../core/resourceReferences.js";
 import { findLayer, resolveEligibleLayer } from "../../selectors/layers.js";
 import { isSourceOwnedText } from "../../grammar/text.js";
@@ -369,6 +370,14 @@ export const applyPointHighlight = /* @__PURE__ */ closedAction(
       throw new Error("applyPointHighlight requires a point selection.");
     }
     if (keys.length === 0) return this;
+    if (isPlainObject(args.style.shape)) {
+      const shape = validatePointShape(args.style.shape);
+      const { selected, items } = selectedGraphicItems(this, resolved, keys);
+      validateWorkLimit(items.reduce((sum, { key, child }) => sum +
+        (selected.has(key) ? shape.polygon.length + 1
+          : child.type === "path" ? child.properties.commands.length : 0), 0),
+      "Point polygon highlight");
+    }
     return editSelectedItems(this, resolved, keys, item =>
       transformPointHighlightChild(item, args.style)
     );