ggaction 0.0.16 → 0.0.17

package/src/actions/data/index.js

@@ -48,6 +48,7 @@ import {
 import { createCompleteData, materializeCompleteData } from "./complete.js";
 import { createImputedData, materializeImputedData } from "./impute.js";
 import { createStackData, materializeStackData } from "./stack.js";
+import { createSortedData, materializeSortedData } from "./sort.js";
 import { EDIT_DERIVED_DATA_ACTIONS } from "./edit.js";
 import { createBoxSummaryData, createBoxOutlierData, materializeBoxSummaryData, materializeBoxOutlierData } from "./box.js";
 
@@ -96,6 +97,8 @@ export function registerDataActions(ProgramClass) {
     materializeImputedData,
     createStackData,
     materializeStackData,
+    createSortedData,
+    materializeSortedData,
     createTimeUnitData,
     materializeTimeUnitData,
     createBin2DData,

package/src/actions/data/interval.js

@@ -13,6 +13,7 @@ const OPTIONS = Object.freeze([
   "extent",
   "method",
   "level",
+  "missing",
   "as"
 ]);
 
@@ -42,6 +43,7 @@ export const createIntervalData = /* @__PURE__ */ derivedCreator(
       extent: args.extent,
       method: args.method,
       level: args.level,
+      missing: args.missing,
       as
     });
   },

package/src/actions/data/regression.js

@@ -11,6 +11,7 @@ import { derivedMaterializer } from "./shared.js";
 const OPTIONS = Object.freeze([
   "id", "source", "x", "y", "groupBy", "method", "degree", "span",
   "confidenceMethod", "level", "confidence", "interval"
+  , "predict", "missing"
 ]);
 
 export const materializeRegressionData = /* @__PURE__ */ derivedMaterializer(
@@ -27,7 +28,9 @@ export const materializeRegressionData = /* @__PURE__ */ derivedMaterializer(
       confidenceMethod: transform.confidenceMethod,
       level: transform.level,
       confidence: transform.confidence,
-      interval: transform.interval
+      interval: transform.interval,
+      predict: transform.predict
+      , missing: transform.missing
     })
 );
 

package/src/actions/data/revise.js

@@ -6,16 +6,48 @@ import { requireLayer } from "../../selectors/layers.js";
 import { applyRevisionPlan, buildSourceRevisionPlan } from "./edit.js";
 import { resolveStoredSelection } from "../../materialization/selection/state.js";
 import { withGuideLayoutTransaction } from "../../materialization/guides/layout.js";
+import { assertFieldsAvailable } from "../../grammar/datasetSchema.js";
 
 let reviseFacet;
 
+function layerInputFields(layer) {
+  const fields = [];
+  const add = value => {
+    if (typeof value === "string" && value.length > 0) fields.push(value);
+  };
+  for (const encoding of Object.values(layer.encoding ?? {})) {
+    if (!encoding || typeof encoding !== "object") continue;
+    add(encoding.field);
+    add(encoding.weight);
+    add(encoding.key);
+    add(encoding.pathOrder?.field);
+    add(encoding.categoryOrder?.by?.field);
+    for (const field of encoding.fields ?? []) add(field);
+    for (const dimension of encoding.dimensions ?? []) add(dimension.field);
+  }
+  return [...new Set(fields)];
+}
+
 export function registerFacetDataRevision(handler) {
   reviseFacet = handler;
 }
 
-export function reviseUnitData(program, { source, id, values }) {
+export function reviseUnitData(program, { source, id, values, schema }) {
   const plan = buildSourceRevisionPlan(program, source, id);
-  const created = program.createData({ id, values });
+  const original = requireDataset(program, source);
+  const inheritedSchema = schema ?? (original.schema?.origin === "declared"
+    ? { fields: original.schema.fields.map(({ name, storageType, nullable, optional }) => ({
+        name, storageType, nullable, optional
+      })) }
+    : undefined);
+  const created = program.createData({ id, values, ...(inheritedSchema === undefined ? {} : { schema: inheritedSchema }) });
+  const revisedSource = requireDataset(created, id);
+  for (const layer of program.semanticSpec.layers.filter(layer => layer.data === source)) {
+    assertFieldsAvailable(revisedSource.schema, layerInputFields(layer), {
+      data: id,
+      operation: "reviseData"
+    });
+  }
   const next = withGuideLayoutTransaction(created, candidate =>
     applyRevisionPlan(candidate, undefined, plan, { retain: new Set([source]) }));
   for (const [selection, config] of Object.entries(next.materializationConfigs.selections ?? {})) {
@@ -27,7 +59,7 @@ export function reviseUnitData(program, { source, id, values }) {
 }
 
 export const reviseData = /* @__PURE__ */ closedAction(
-  { op: "reviseData", description: "Revise source data and its dependent chart.", scope: "any" }, ["source", "id", "values"],
+  { op: "reviseData", description: "Revise source data and its dependent chart.", scope: "any" }, ["source", "id", "values", "schema"],
   function (args = {}) {
     const source = validateUserId(args.source, "Source dataset id");
     const id = validateUserId(args.id, "Revision dataset id");
@@ -39,8 +71,8 @@ export const reviseData = /* @__PURE__ */ closedAction(
       throw new Error(`Source "${source}" must be a materialized original dataset.`);
     }
     const apply = this.compositionSpec === undefined
-      ? program => reviseUnitData(program, { source, id, values: args.values }).program
-      : program => reviseFacet(program, { source, id, values: args.values });
+      ? program => reviseUnitData(program, { source, id, values: args.values, schema: args.schema }).program
+      : program => reviseFacet(program, { source, id, values: args.values, schema: args.schema });
     // The entire dependent materialization must succeed before returning a revision.
     apply(this);
     return apply(this);

package/src/actions/data/shared.js

@@ -5,6 +5,12 @@ import {
   findDataset,
   resolveDatasetReference
 } from "../../selectors/datasets.js";
+import {
+  assertFieldsAvailable,
+  deriveTransformSchema,
+  transformInputFields,
+  validateRowsAgainstSchema
+} from "../../grammar/datasetSchema.js";
 
 export const MATERIALIZE_OPTIONS = Object.freeze(["id"]);
 
@@ -37,17 +43,39 @@ export function derivedMaterializer(op, description, type, derive, resolve) {
       args.id,
       type
     );
+    assertFieldsAvailable(source.schema, transformInputFields(transform), {
+      data: source.id,
+      operation: op
+    });
     const result = derive(source.values, transform);
+    const values = Array.isArray(result) ? result : result.values;
+    const schema = deriveTransformSchema(source.schema, transform, values, {
+      sourceId: source.id,
+      ownerId: id
+    });
+    validateRowsAgainstSchema(values, schema, `Derived dataset "${id}"`);
     const program = resolve === undefined
       ? this
       : this.editSemantic({
           property: `dataset[${id}].transform`,
           value: resolve(result, transform)
         });
-    return program.editSemantic({
+    let next = program.editSemantic({
       property: `dataset[${id}].values`,
-      value: Array.isArray(result) ? result : result.values
+      value: values
     });
+    if (!Array.isArray(result) && result.report !== undefined) {
+      const report = {
+        ...result.report,
+        owner: { kind: "data", id },
+        inputs: [{ kind: "data", id: source.id }]
+      };
+      next = next._withMaterializationConfig(
+        ["calculations", "datasets", id],
+        report
+      );
+    }
+    return next;
   });
 }
 

package/src/actions/data/sort.js

@@ -0,0 +1,21 @@
+import { deriveSortedRows, normalizeSortTransform } from "../../grammar/sort.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
+
+const OPTIONS = Object.freeze(["id", "source", "sortBy"]);
+
+export const materializeSortedData = /* @__PURE__ */ derivedMaterializer(
+  "materializeSortedData",
+  "Materialize one immutable stable sorted dataset.",
+  "sort",
+  deriveSortedRows
+);
+
+export const createSortedData = /* @__PURE__ */ derivedCreator(
+  "createSortedData",
+  "Create reusable rows in a stable explicit order.",
+  OPTIONS,
+  "Sorted dataset id",
+  "Sorted source dataset id",
+  normalizeSortTransform,
+  "materializeSortedData"
+);

package/src/actions/data/summary.js

@@ -5,7 +5,7 @@ import {
 import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "source", "groupBy", "aggregates", "members", "weight"
+  "id", "source", "groupBy", "aggregates", "members", "weight", "missing", "empty"
 ]);
 
 export const materializeSummaryData = /* @__PURE__ */ derivedMaterializer(

package/src/actions/encodings/angle.js

@@ -5,6 +5,8 @@ import {
   setEncodingProperties,
   validateOptions
 } from "./shared.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const OPTIONS = Object.freeze(["target", "value", "field", "fieldType"]);
 
@@ -29,7 +31,7 @@ export const encodeAngle = /* @__PURE__ */ action(
     if (hasValue && args.fieldType !== undefined) {
       throw new Error("Constant angle does not accept fieldType.");
     }
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       ["point", "tick"],
@@ -39,6 +41,7 @@ export const encodeAngle = /* @__PURE__ */ action(
       throw new TypeError("encodeAngle value must be finite degrees.");
     }
     if (hasField) {
+      const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
       const fieldType = args.fieldType ?? "quantitative";
       if (fieldType !== "quantitative") {
         throw new Error("encodeAngle requires a quantitative field.");

package/src/actions/encodings/appearance.js

@@ -25,6 +25,8 @@ import {
   setEncodingProperties,
   validateOptions
 } from "./shared.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const RADIUS_OPTIONS = Object.freeze(["value", "target"]);
 const REMOVE_RADIUS_OPTIONS = Object.freeze(["target"]);
@@ -34,13 +36,14 @@ const OPACITY_OPTIONS = Object.freeze([
 const FIELD_OPTIONS = Object.freeze(["field", "target", "fieldType", "scale"]);
 function encodeAppearanceField(program, channel, args, operation) {
   validateOptions(args, FIELD_OPTIONS, operation);
-  const { id: target, dataset, layer } = resolveTarget(
+  const { id: target, dataset: sourceDataset, layer } = resolveTarget(
     program,
     args.target,
     ["point"],
     "point mark"
   );
   const expectedFieldType = channel === "shape" ? "nominal" : "quantitative";
+  const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
   const fieldType = args.fieldType ?? expectedFieldType;
   if (fieldType !== expectedFieldType) {
     throw new Error(`${operation} requires a ${expectedFieldType} field.`);
@@ -196,7 +199,7 @@ const encodeOpacity = /* @__PURE__ */ action(
     if (hasValue && (args.fieldType !== undefined || args.scale !== undefined)) {
       throw new Error("Constant opacity does not accept fieldType or scale.");
     }
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       ["point", "rule", "line"],
@@ -222,6 +225,7 @@ const encodeOpacity = /* @__PURE__ */ action(
         : next.rematerializePointMark({ id: target });
       return applyDetachedScaleRematerialization(materialized, [layer]);
     }
+    const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
     const fieldType = args.fieldType ?? "quantitative";
     if (fieldType !== "quantitative") {
       throw new Error("encodeOpacity requires a quantitative field.");

package/src/actions/encodings/color/continuous.js

@@ -26,6 +26,8 @@ import {
 } from "./policy.js";
 
 import { applyTemporalUnit } from "../temporal.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../../grammar/itemMissing.js";
 
 export function encodeContinuousColor(program, args) {
   if (!["quantitative", "temporal"].includes(args.fieldType)) {
@@ -34,12 +36,13 @@ export function encodeContinuousColor(program, args) {
   if (args.layout !== undefined) {
     throw new Error("Continuous color does not support layout.");
   }
-  const { id: target, dataset, layer } = resolveTarget(
+  const { id: target, dataset: sourceDataset, layer } = resolveTarget(
     program,
     args.target,
     ["point", "bar", "rect"],
     "continuous color mark"
   );
+  const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
   assertNoConstantColor(program, layer);
   const temporalUnit = resolveTemporalUnit(args, args.fieldType, layer.encoding?.color);
   const requestedScale = resolveReassignmentScaleOptions(

package/src/actions/encodings/color/index.js

@@ -38,6 +38,8 @@ import {
 } from "./policy.js";
 
 import { applyTemporalUnit } from "../temporal.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../../grammar/itemMissing.js";
 
 const encodeColor = /* @__PURE__ */ action(
   {
@@ -58,12 +60,13 @@ const encodeColor = /* @__PURE__ */ action(
     }
     const fieldType = validateCategoricalFieldType(requestedFieldType);
     resolveTemporalUnit(args, fieldType);
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       ["point", "line", "bar", "area", "arc", "rect"],
       "color mark"
     );
+    const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
     assertNoConstantColor(this, layer);
     const densityTransform = dataset.transform?.length === 1 &&
       dataset.transform[0].type === "density"

package/src/actions/encodings/offset.js

@@ -18,6 +18,8 @@ import {
   resolveBarChannels,
   resolveBarGrain
 } from "../../grammar/bars/policy.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const ENCODING_OPTIONS = Object.freeze([
   "field", "target", "fieldType", "scale", "paddingInner", "paddingOuter"
@@ -33,12 +35,13 @@ function createOffsetEncoding(channel) {
     function (args = {}) {
       validateOptions(args, ENCODING_OPTIONS, operation);
       const fieldType = validateCategoricalFieldType(args.fieldType ?? "nominal");
-      const { id: target, dataset, layer } = resolveTarget(
+      const { id: target, dataset: sourceDataset, layer } = resolveTarget(
         this,
         args.target,
         ["bar", "point", "rule"],
         "offset-compatible mark"
       );
+      const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
 
       if (layer.mark.type === "bar") {
         const channels = resolveBarChannels(layer);

package/src/actions/encodings/position/resolve.js

@@ -13,6 +13,8 @@ import {
   validateFieldType,
   validatePositionChannel
 } from "../../../grammar/scales/index.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../../grammar/itemMissing.js";
 import { resolvePositionScaleDefinition } from "../../scales/definitions.js";
 import { findCoordinate } from "../../../selectors/coordinates.js";
 import {
@@ -92,7 +94,7 @@ function resolveCoordinate(program, channel, layer, requestedId) {
 export function resolvePositionEncoding(program, channel, args, operation) {
   validateOptions(args, POSITION_ENCODING_OPTIONS, operation);
   validatePositionChannel(channel);
-  const { id: target, dataset, layer } = resolveTarget(
+  const { id: target, dataset: sourceDataset, layer } = resolveTarget(
     program,
     args.target,
     getPositionChannelDefinition(channel).markTypes
@@ -157,6 +159,9 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     xEncoding?.bin !== undefined && args.field === undefined
     ? xEncoding.field
     : args.field;
+  const dataset = hasField
+    ? applyRequestedItemMissingPolicy(layer, sourceDataset, field)
+    : applyRequestedItemMissingPolicy(layer, sourceDataset);
   const datum = args.datum;
   const temporalUnit = resolveTemporalUnit({ ...args, ...(hasDatum ? {} : { field }) }, fieldType, previous);
   const usesField = !countRadius && (!["rule", "area", "rect", "text", "point", "tick"].includes(layer.mark.type) || hasField);

package/src/actions/encodings/ranged.js

@@ -14,6 +14,8 @@ import { deriveAreaSeries } from "../../grammar/areaSeries.js";
 import { resolvePositionEncoding } from "./position/resolve.js";
 import { resolveScalePreview } from "../scales/preview.js";
 import { findUpstreamTransform } from "../../materialization/dataProvenance.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const SECONDARY_OPTIONS = Object.freeze([
   "field", "datum", "target", "fieldType", "scale", "coordinate", "temporalUnit"
@@ -46,7 +48,7 @@ function validateSecondaryField(dataset, field, fieldType, temporalUnit) {
 
 function encodeSecondaryPosition(program, channel, args, operation, types) {
   validateOptions(args, SECONDARY_OPTIONS, operation);
-  const { id: target, dataset, layer } = resolveTarget(
+  const { id: target, dataset: sourceDataset, layer } = resolveTarget(
     program,
     args.target,
     types,
@@ -72,6 +74,9 @@ function encodeSecondaryPosition(program, channel, args, operation, types) {
   const rect = layer.mark.type === "rect";
   const hasField = Object.hasOwn(args, "field");
   const hasDatum = Object.hasOwn(args, "datum");
+  const dataset = hasField
+    ? applyRequestedItemMissingPolicy(layer, sourceDataset, args.field)
+    : applyRequestedItemMissingPolicy(layer, sourceDataset);
   if ((rule || area || rect) && hasField === hasDatum) {
     throw new Error(`${operation} requires exactly one of field or datum for a ${layer.mark.type} mark.`);
   }

package/src/actions/encodings/ruleAppearance.js

@@ -14,6 +14,8 @@ import {
 import { findLayer } from "../../selectors/layers.js";
 import { validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
 import { assertEncodingSelectionCompatibility } from "../../materialization/selection/compatibility.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const WIDTH_OPTIONS = Object.freeze([
   "target", "value", "field", "fieldType", "scale"
@@ -57,12 +59,13 @@ const encodeStrokeWidth = /* @__PURE__ */ action(
       next = next.rematerializeRuleMark({ id });
       return applyDetachedScaleRematerialization(next, [layer]);
     }
-    const { id, dataset, layer } = resolveTarget(
+    const { id, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       ["rule", "line"],
       "rule or line mark"
     );
+    const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
     const fieldType = args.fieldType ?? "quantitative";
     if (fieldType !== "quantitative") {
       throw new Error("encodeStrokeWidth requires a quantitative field.");

package/src/actions/encodings/stroke.js

@@ -26,6 +26,8 @@ import {
   setEncodingProperties,
   validateOptions
 } from "./shared.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const OPTIONS = Object.freeze([
   "target", "value", "field", "fieldType", "temporalUnit", "scale"
@@ -122,7 +124,7 @@ export const encodeStroke = /* @__PURE__ */ action(
         "Constant stroke does not accept fieldType, temporalUnit, or scale."
       );
     }
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       MARK_TYPES,
@@ -155,6 +157,7 @@ export const encodeStroke = /* @__PURE__ */ action(
     }
 
     const fieldType = args.fieldType ?? "nominal";
+    const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
     const previous = layer.encoding?.stroke;
     const temporalUnit = resolveTemporalUnit(args, fieldType, previous);
     const requestedScale = resolveReassignmentScaleOptions(

package/src/actions/encodings/strokeDash.js

@@ -15,6 +15,8 @@ import {
 } from "./shared.js";
 import { findLayer } from "../../selectors/layers.js";
 import { validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const STROKE_DASH_ENCODING_OPTIONS = Object.freeze([
   "field", "value", "target", "fieldType", "scale"
@@ -73,12 +75,15 @@ const encodeStrokeDash = /* @__PURE__ */ action(
     if (hasValue && (args.fieldType !== undefined || args.scale !== undefined)) {
       throw new Error("Constant stroke dash does not accept fieldType or scale.");
     }
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       ["line", "rule"],
       "line or rule mark"
     );
+    const dataset = hasField
+      ? applyRequestedItemMissingPolicy(layer, sourceDataset, args.field)
+      : sourceDataset;
     if (hasValue) {
       normalizeStrokeDashPattern(args.value);
       validatePathSeriesAppearance(dataset.values, {

package/src/actions/encodings/text.js

@@ -9,6 +9,8 @@ import {
   setEncodingProperties,
   validateOptions
 } from "./shared.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const OPTIONS = Object.freeze(["target", "field", "value", "content", "normalizeBy", "format"]);
 
@@ -41,12 +43,15 @@ export const encodeText = /* @__PURE__ */ action(
     if (Object.hasOwn(args, "normalizeBy") && (!hasContent || args.content !== "share")) {
       throw new Error("Text normalizeBy is only supported with share content.");
     }
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       ["text"],
       "text mark"
     );
+    const dataset = hasField
+      ? applyRequestedItemMissingPolicy(layer, sourceDataset, args.field)
+      : applyRequestedItemMissingPolicy(layer, sourceDataset);
     const previous = layer.encoding?.text;
     const format = validateTextFormat(args.format ?? previous?.format ?? "auto");
     const content = hasContent

package/src/actions/marks/bar/create.js

@@ -14,9 +14,10 @@ import { requestedRectStyleDetails } from
   "../../../grammar/roundedRect.js";
 import { STROKE_STYLE_PROPERTIES } from
   "../../../grammar/strokeStyle.js";
+import { validateItemMissing } from "../../../grammar/itemMissing.js";
 
 const CREATE_OPTIONS = Object.freeze([
-  "id", "data", "fill", "opacity", "stroke", "strokeWidth",
+  "id", "data", "missing", "fill", "opacity", "stroke", "strokeWidth",
   "cornerRadius", ...STROKE_STYLE_PROPERTIES
 ]);
 
@@ -52,6 +53,12 @@ export const createBarMark = /* @__PURE__ */ action(
         property: `layer[${id}].data`,
         value: data
       });
+    if (Object.hasOwn(args, "missing")) {
+      created = created.editSemantic({
+        property: `layer[${id}].mark.missing`,
+        value: validateItemMissing(args.missing, "Bar missing")
+      });
+    }
     created = applyLayeredMarkInheritance(created, id, inherited);
     created = created
       .createGraphics({

package/src/actions/marks/bar/edit.js

@@ -14,9 +14,10 @@ import { requestedRectStyleDetails } from
 import { STROKE_STYLE_PROPERTIES } from
   "../../../grammar/strokeStyle.js";
 import { rematerializeExistingLegend } from "../../encodings/shared.js";
+import { validateItemMissing } from "../../../grammar/itemMissing.js";
 
 const EDIT_OPTIONS = Object.freeze([
-  "target", "fill", "opacity", "stroke", "strokeWidth", "cornerRadius",
+  "target", "missing", "fill", "opacity", "stroke", "strokeWidth", "cornerRadius",
   ...STROKE_STYLE_PROPERTIES
 ]);
 
@@ -29,12 +30,12 @@ export const editBarMark = /* @__PURE__ */ action(
     validateMarkOptions(args, EDIT_OPTIONS, "editBarMark");
     const styleDetails = requestedRectStyleDetails(args, "editBarMark");
     const changes = [
-      "fill", "opacity", "stroke", "strokeWidth", "cornerRadius",
+      "missing", "fill", "opacity", "stroke", "strokeWidth", "cornerRadius",
       ...STROKE_STYLE_PROPERTIES
     ];
     if (!changes.some(key => Object.hasOwn(args, key))) {
       throw new Error(
-        "editBarMark requires fill, opacity, stroke, or strokeWidth."
+        "editBarMark requires fill, opacity, stroke, or strokeWidth; missing is also editable."
       );
     }
     const requested = Object.hasOwn(args, "target")
@@ -61,7 +62,13 @@ export const editBarMark = /* @__PURE__ */ action(
       );
     }
 
-    const config = { ...this.markConfigs[layer.id] };
+    const semantic = Object.hasOwn(args, "missing")
+      ? this.editSemantic({
+          property: `layer[${layer.id}].mark.missing`,
+          value: validateItemMissing(args.missing, "Bar missing")
+        })
+      : this;
+    const config = { ...semantic.markConfigs[layer.id] };
     const appearance = { ...config.barAppearance };
     Object.assign(appearance, styleDetails);
     if (Object.hasOwn(args, "fill")) {
@@ -95,7 +102,7 @@ export const editBarMark = /* @__PURE__ */ action(
       );
     }
 
-    const next = this._withMarkConfig(layer.id, {
+    const next = semantic._withMarkConfig(layer.id, {
       ...config,
       barAppearance: appearance
     });

package/src/actions/marks/point/create.js

@@ -16,9 +16,10 @@ import {
   resolveMarkId,
   validateMarkOptions
 } from "../shared.js";
+import { validateItemMissing } from "../../../grammar/itemMissing.js";
 
 const OPTIONS = Object.freeze([
-  "id", "data", "shape", "fill", "opacity", "stroke", "strokeWidth",
+  "id", "data", "missing", "shape", "fill", "opacity", "stroke", "strokeWidth",
   ...STROKE_STYLE_PROPERTIES
 ]);
 
@@ -61,6 +62,12 @@ export const createPointMark = /* @__PURE__ */ action(
         property: `layer[${id}].data`,
         value: data
       });
+    if (Object.hasOwn(args, "missing")) {
+      next = next.editSemantic({
+        property: `layer[${id}].mark.missing`,
+        value: validateItemMissing(args.missing, "Point missing")
+      });
+    }
     next = applyLayeredMarkInheritance(next, id, inherited)
       .createGraphics({
         id,