ggaction 0.0.16 → 0.0.18

package/src/actions/charts/interval-regression.js

@@ -135,7 +135,7 @@ export const createIntervalPlot = /* @__PURE__ */ action(
 
 const REGRESSION_OPTIONS = Object.freeze([
   "id", "data", "coordinate", "x", "y", "color", "size", "shape", "point",
-  "groupBy", "method", "degree", "span", "confidenceMethod", "level", "confidence",
+  "groupBy", "method", "degree", "span", "robustIterations", "confidenceMethod", "level", "confidence",
   "interval", "band", "line", "guides"
 ]);
 
@@ -163,7 +163,7 @@ export const createRegressionPlot = /* @__PURE__ */ action(
       guides: false
     });
     const regression = Object.fromEntries([
-      "groupBy", "method", "degree", "span", "confidenceMethod", "level",
+      "groupBy", "method", "degree", "span", "robustIterations", "confidenceMethod", "level",
       "confidence", "interval", "band", "line"
     ].filter(key => Object.hasOwn(args, key)).map(key => [key, args[key]]));
     next = next.createRegression({ target: id, ...regression });

package/src/actions/charts/line.js

@@ -20,7 +20,7 @@ const OPTIONS = Object.freeze([
   "strokeDash", "line", "guides"
 ]);
 const LINE_OPTIONS = Object.freeze([
-  "strokeWidth", "curve", "stroke", "opacity", "closed",
+  "strokeWidth", "curve", "tension", "stroke", "opacity", "closed",
   ...STROKE_STYLE_PROPERTIES
 ]);
 

package/src/actions/charts/pie.js

@@ -1,52 +1,8 @@
 import { action } from "../../core/action.js";
-import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
-import {
-  applyFacadeGuides, normalizeAppearance, normalizeCategoricalColor, normalizeCategoricalGuides,
-  normalizeArcCategory, normalizeCategoryAggregate, omitUndefinedOptions,
-  resolveFacadeData, resolveFacadeId, validateFacadeOptions
-} from "./shared.js";
-
-const OPERATION = "createPiePlot";
-const OPTIONS = ["id", "data", "coordinate", "category", "value", "aggregate", "color", "arc", "guides"];
-const ARC_OPTIONS = [
-  "innerRadius", "padAngle", "fill", "opacity", "stroke", "strokeWidth",
-  ...STROKE_STYLE_PROPERTIES
-];
-function guideOptions(value, color) {
-  const guides = normalizeCategoricalGuides(value, OPERATION, color);
-  if (guides === false) return false;
-  for (const key of ["axes", "grid"]) {
-    if (guides[key] !== undefined && guides[key] !== false) {
-      throw new TypeError(`${OPERATION} guides.${key} only accepts false.`);
-    }
-  }
-  return { ...guides, axes: false, grid: false };
-}
+import { createArcPlot } from "./radial.js";
 
 export const createPiePlot = /* @__PURE__ */ action({
-  op: OPERATION, description: "Create a categorical count or weighted-sum pie or donut plot."
+  op: "createPiePlot", description: "Create a categorical count or weighted-sum pie or donut plot."
 }, function (args = {}) {
-  validateFacadeOptions(args, OPTIONS, OPERATION);
-  const id = resolveFacadeId(this, args.id, { defaultId: "piePlot", operation: OPERATION });
-  const data = resolveFacadeData(this, args.data, OPERATION);
-  const category = normalizeArcCategory(args.category, OPERATION);
-  const aggregate = normalizeCategoryAggregate(args, OPERATION);
-  const arc = omitUndefinedOptions(normalizeAppearance(args.arc, ARC_OPTIONS, `${OPERATION} arc`));
-  const color = args.color === false ? undefined
-    : normalizeCategoricalColor(args.color === undefined ? category.field : args.color, `${OPERATION} color`);
-  if (color !== undefined && arc.fill !== undefined) {
-    throw new Error(`${OPERATION} arc.fill cannot be combined with color; use color:false.`);
-  }
-  const guides = guideOptions(args.guides, color);
-  let next = this.createArcMark({ id, data, ...arc }).encodeTheta({
-    ...category, target: id, aggregate,
-    ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate }),
-    ...(aggregate === "sum" ? { weight: args.value } : {})
-  });
-  if (color !== undefined) next = next.encodeColor({ ...color, target: id });
-  next = applyFacadeGuides(next, guides, id, args.guides ?? {});
-  return next._withMarkConfig(id, {
-    ...next.markConfigs[id],
-    compositionRole: "pie"
-  });
+  return createArcPlot(this, args, { operation: "createPiePlot", defaultId: "piePlot" });
 });

package/src/actions/charts/radial.js

@@ -1,3 +1,4 @@
+import { findSemanticScale } from "../../selectors/scales.js";
 import { action } from "../../core/action.js";
 import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
@@ -6,21 +7,22 @@ import {
   resolveFacadeData, resolveFacadeId, validateFacadeOptions
 } from "./shared.js";
 
-const OPTIONS = ["id", "data", "coordinate", "category", "value", "aggregate", "radiusScale", "color", "arc", "guides"];
+const OPTIONS = ["id", "data", "coordinate", "category", "value", "aggregate", "color", "arc", "guides"];
 const ARC_OPTIONS = [
   "innerRadius", "padAngle", "fill", "opacity", "stroke", "strokeWidth",
   ...STROKE_STYLE_PROPERTIES
 ];
 const RADIUS_OPTIONS = ["id", "type", "domain", "range", "zero", "nice", "reverse", "clamp"];
 
-function createMeasuredPlot(program, args, { operation, defaultId, mapping }) {
-  validateFacadeOptions(args, OPTIONS, operation);
+export function createArcPlot(program, args, { operation, defaultId, mapping }) {
+  const measured = mapping !== undefined;
+  validateFacadeOptions(args, [...OPTIONS, measured ? "radiusScale" : "radius"], operation);
   const id = resolveFacadeId(program, args.id, { defaultId, operation });
   const data = resolveFacadeData(program, args.data, operation);
   const category = normalizeArcCategory(args.category, operation);
   const aggregate = normalizeCategoryAggregate(args, operation);
   const arc = omitUndefinedOptions(normalizeAppearance(args.arc, ARC_OPTIONS, `${operation} arc`));
-  if (arc.padAngle !== undefined && arc.padAngle !== 0) throw new Error(`${operation} requires padAngle 0.`);
+  if (measured && arc.padAngle !== undefined && arc.padAngle !== 0) throw new Error(`${operation} requires padAngle 0.`);
   const radiusScale = args.radiusScale === undefined ? undefined
     : omitUndefinedOptions(normalizeAppearance(args.radiusScale, RADIUS_OPTIONS, `${operation} radiusScale`));
   const color = args.color === false ? undefined
@@ -28,23 +30,43 @@ function createMeasuredPlot(program, args, { operation, defaultId, mapping }) {
   if (color !== undefined && arc.fill !== undefined) {
     throw new Error(`${operation} arc.fill cannot be combined with color; use color:false.`);
   }
-  const guides = normalizeCategoricalGuides(args.guides, operation, color);
+  let guides = normalizeCategoricalGuides(args.guides, operation, color);
+  if (!measured && guides !== false) {
+    for (const key of ["axes", "grid"]) {
+      if (guides[key] !== undefined && guides[key] !== false) {
+        throw new TypeError(`${operation} guides.${key} only accepts false.`);
+      }
+    }
+    guides = { ...guides, axes: false, grid: false };
+  }
   let next = program.createArcMark({ id, data, ...arc }).encodeTheta({
-    ...category, target: id, ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate })
-  }).encodeR({ target: id, aggregate, mapping,
-    ...(aggregate === "sum" ? { field: args.value } : {}),
-    ...(radiusScale === undefined ? {} : { scale: radiusScale }) });
+    ...category, target: id, ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate }),
+    ...(!measured ? { aggregate, ...(aggregate === "sum" ? { weight: args.value } : {}) } : {})
+  });
+  if (measured) {
+    next = next.encodeR({ target: id, aggregate, mapping,
+      ...(aggregate === "sum" ? { field: args.value } : {}),
+      ...(radiusScale === undefined ? {} : { scale: radiusScale }) });
+  } else if (args.radius !== undefined) {
+    const radius = typeof args.radius === "string" ? { field: args.radius }
+      : normalizeAppearance(args.radius, ["field", "aggregate", "scale"], `${operation} radius`);
+    const scale = radius.scale ?? {};
+    next = next.encodeR({ target: id, ...omitUndefinedOptions(radius), scale: {
+      ...(scale.type !== "log" && findSemanticScale(next, scale.id ?? "radius") === undefined ? { zero: true } : {}),
+      ...scale
+    } });
+  }
   if (color !== undefined) next = next.encodeColor({ ...color, target: id });
   next = applyFacadeGuides(next, guides, id, args.guides ?? {});
   return next._withMarkConfig(id, {
     ...next.markConfigs[id],
-    compositionRole: "rose"
+    compositionRole: measured ? "rose" : "pie"
   });
 }
 
 export const createRosePlot = /* @__PURE__ */ action({ op: "createRosePlot", description: "Create equal-angle sectors with area proportional to category count or sum." }, function (args = {}) {
-  return createMeasuredPlot(this, args, { operation: "createRosePlot", defaultId: "rosePlot", mapping: "area" });
+  return createArcPlot(this, args, { operation: "createRosePlot", defaultId: "rosePlot", mapping: "area" });
 });
 export const createRadialBarPlot = /* @__PURE__ */ action({ op: "createRadialBarPlot", description: "Create equal-angle sectors with radial length proportional to category count or sum." }, function (args = {}) {
-  return createMeasuredPlot(this, args, { operation: "createRadialBarPlot", defaultId: "radialBarPlot", mapping: "radius-length" });
+  return createArcPlot(this, args, { operation: "createRadialBarPlot", defaultId: "radialBarPlot", mapping: "radius-length" });
 });

package/src/actions/charts/scatter.js

@@ -1,3 +1,4 @@
+import { encodeStroke } from "../encodings/stroke.js";
 import { action } from "../../core/action.js";
 import { validateNonNegativeFinite } from "../../core/validation.js";
 import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
@@ -15,7 +16,7 @@ import {
 } from "./shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "data", "coordinate", "x", "y", "color", "size", "shape",
+  "id", "data", "coordinate", "x", "y", "color", "stroke", "size", "shape",
   "point", "guides"
 ]);
 const POINT_OPTIONS = Object.freeze([
@@ -43,6 +44,13 @@ export const createScatterPlot = /* @__PURE__ */ action(
     const x = normalizeFieldEncoding(args.x, "createScatterPlot x");
     const y = normalizeFieldEncoding(args.y, "createScatterPlot y");
     const color = normalizeEncoding(args.color, "createScatterPlot color");
+    const stroke = normalizeEncoding(args.stroke, "createScatterPlot stroke");
+    if (stroke !== undefined) {
+      if (typeof stroke.field !== "string" || stroke.field.length === 0 || Object.hasOwn(stroke, "value")) {
+        throw new TypeError("createScatterPlot stroke requires a field; constant stroke belongs in point.");
+      }
+      if (Object.hasOwn(point, "stroke")) throw new Error("createScatterPlot stroke conflicts with point.stroke.");
+    }
     const size = normalizeEncoding(args.size, "createScatterPlot size");
     const shape = normalizeEncoding(args.shape, "createScatterPlot shape");
     const guides = normalizeGuides(args.guides, "createScatterPlot");
@@ -51,12 +59,18 @@ export const createScatterPlot = /* @__PURE__ */ action(
       if (size !== undefined) throw new Error("createScatterPlot point radius conflicts with size.");
     }
 
+    const initialPoint = { ...point };
+    if (stroke !== undefined) delete initialPoint.strokeWidth;
     let next = this
-      .createPointMark({ id, data, ...point })
+      .createPointMark({ id, data, ...initialPoint })
       .encodeX(positionArgs(x, { target: id, coordinate: args.coordinate }))
       .encodeY(positionArgs(y, { target: id, coordinate: args.coordinate }));
     if (radius !== undefined) next = next.encodePointRadius({ target: id, value: radius });
     if (color !== undefined) next = next.encodeColor(targetArgs(color, id));
+    if (stroke !== undefined) {
+      next = encodeStroke.call(next, targetArgs(stroke, id));
+      if (Object.hasOwn(point, "strokeWidth")) next = next.editPointMark({ target: id, strokeWidth: point.strokeWidth });
+    }
     if (size !== undefined) next = next.encodeSize(targetArgs(size, id));
     if (shape !== undefined) next = next.encodeShape(targetArgs(shape, id));
     return applyFacadeGuides(next, guides, id);

package/src/actions/charts/shared.js

@@ -191,9 +191,9 @@ export function normalizeArcCategory(value, operation) {
 }
 
 export function normalizeCategoryAggregate(args, operation) {
-  const aggregate = args.aggregate === undefined ? "count" : args.aggregate;
+  const aggregate = args.aggregate === undefined ? args.value === undefined ? "count" : "sum" : args.aggregate;
   if (!["count", "sum"].includes(aggregate) || (aggregate === "sum") !== (args.value !== undefined)) {
-    throw new Error(`${operation} requires count without value or explicit sum with value.`);
+    throw new Error(`${operation} requires count without value or sum with value.`);
   }
   if (args.value !== undefined) validateNonEmptyString(args.value, `${operation} value`);
   return aggregate;

package/src/actions/charts/text.js

@@ -0,0 +1,35 @@
+import { action } from "../../core/action.js";
+import { TEXT_MARK_STYLE_OPTIONS } from "../../grammar/text.js";
+import {
+  applyFacadeGuides, normalizeAppearance, normalizeEncoding, normalizeFieldEncoding,
+  normalizeGuides, positionArgs, resolveFacadeData, resolveFacadeId, targetArgs,
+  validateFacadeOptions
+} from "./shared.js";
+
+const OPTIONS = Object.freeze(["id", "data", "coordinate", "x", "y", "text", "color", "style", "guides"]);
+const STYLE_OPTIONS = Object.freeze(["missing", ...TEXT_MARK_STYLE_OPTIONS.filter(key => key !== "inheritColor")]);
+
+export const createTextPlot = /* @__PURE__ */ action({
+  op: "createTextPlot", description: "Create a Cartesian text plot from existing chart data."
+}, function (args = {}) {
+  validateFacadeOptions(args, OPTIONS, "createTextPlot");
+  const id = resolveFacadeId(this, args.id, { defaultId: "textPlot", operation: "createTextPlot" });
+  const data = resolveFacadeData(this, args.data, "createTextPlot");
+  const x = normalizeFieldEncoding(args.x, "createTextPlot x");
+  const y = normalizeFieldEncoding(args.y, "createTextPlot y");
+  const text = normalizeEncoding(args.text, "createTextPlot text");
+  if (text === undefined) throw new Error("createTextPlot requires text.");
+  const color = normalizeEncoding(args.color, "createTextPlot color");
+  const style = normalizeAppearance(args.style, STYLE_OPTIONS, "createTextPlot style");
+  const guides = normalizeGuides(args.guides, "createTextPlot");
+  const apply = program => {
+    let next = program.createTextMark({ id, data, ...style })
+      .encodeX(positionArgs(x, { target: id, coordinate: args.coordinate }))
+      .encodeY(positionArgs(y, { target: id, coordinate: args.coordinate }))
+      .encodeText(targetArgs(text, id));
+    if (color !== undefined) next = next.encodeColor(targetArgs(color, id));
+    return applyFacadeGuides(next, guides, id);
+  };
+  apply(this);
+  return apply(this);
+});

package/src/actions/composition/actions.js

@@ -1,3 +1,4 @@
+import { resolveGraphicBounds } from "../../layout/canvas.js";
 import { inheritTextMetrics } from "../textMetrics/index.js";
 import { action, closedAction } from "../../core/action.js";
 import { ChartProgram as CoreChartProgram } from "../../core/ChartProgram.js";
@@ -19,7 +20,7 @@ const CONCAT_OPTIONS = Object.freeze([
   "id", "programs", "gap", "align", "padding"
 ]);
 const LAYOUT_EDIT_OPTIONS = Object.freeze([
-  "columns", "gap", "align", "padding"
+  "columns", "gap", "spacing", "align", "padding"
 ]);
 const REPLACEMENT_OPTIONS = Object.freeze(["target", "program"]);
 const INSERTION_OPTIONS = Object.freeze(["id", "program", "before", "after"]);
@@ -179,6 +180,7 @@ const editCompositionLayout = /* @__PURE__ */ closedAction(
         "editCompositionLayout columns is available only on a facet composition."
       );
     }
+    if (current.type !== "facet" && Object.hasOwn(args, "spacing")) throw new Error("Plot spacing requires a facet composition.");
     const padding = Object.hasOwn(args, "padding")
       ? normalizeCompositionPadding(args.padding, current.padding)
       : current.padding;
@@ -188,6 +190,8 @@ const editCompositionLayout = /* @__PURE__ */ closedAction(
         (current.facet.grid?.cells ?? []).map(cell => [cell.id, cell])
       );
       layout = resolveFacetLayout({
+        spacing: option(args, "spacing", current.spacing),
+        plots: current.children.map(id => ({ id, ...resolveGraphicBounds(this.children[id]) })),
         children: current.children.map((id, index) => ({
           ...childDescriptor({ id, program: this.children[id] }),
           value: current.facet.values[index],
@@ -218,7 +222,7 @@ const editCompositionLayout = /* @__PURE__ */ closedAction(
       children: this.children,
       compositionSpec: {
         ...current,
-        ...(current.type === "facet" ? { columns: layout.columns } : {}),
+        ...(current.type === "facet" ? { columns: layout.columns, ...(layout.spacing !== undefined ? { spacing: layout.spacing } : current.spacing !== undefined ? { spacing: "canvas" } : {}) } : {}),
         gap: layout.gap,
         align: layout.align,
         padding: layout.padding

package/src/actions/data/bin.js

@@ -7,7 +7,7 @@ import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
   "id", "source", "field", "maxBins", "step", "boundaries", "extent",
-  "nice", "zero", "includeEmpty", "members", "as", "weight"
+  "nice", "zero", "includeEmpty", "members", "as", "weight", "missing"
 ]);
 
 export const materializeBinData = /* @__PURE__ */ derivedMaterializer(

package/src/actions/data/box.js

@@ -2,7 +2,7 @@ import { BOX_FIELDS, deriveBoxData, normalizeBoxTransform } from "../../grammar/
 import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "source", "category", "field", "whisker", "factor", "as"
+  "id", "source", "category", "field", "whisker", "factor", "as", "summary"
 ]);
 
 function materializer(type, op, select) {
@@ -28,6 +28,7 @@ function creator(type, op, materialize) {
       type,
       category: args.category,
       field: args.field,
+      ...(args.summary === undefined ? {} : { summary: args.summary }),
       ...(args.whisker === undefined ? {} : { whisker: args.whisker }),
       ...(args.factor === undefined ? {} : { factor: args.factor }),
       as: args.as ?? BOX_FIELDS

package/src/actions/data/create.js

@@ -2,8 +2,13 @@ import { closedAction } from "../../core/action.js";
 import { resolveOptionalUserId } from "../../core/identifiers.js";
 import { validateDataRows } from "../../core/validation.js";
 import { hasDataset, hasDatasetOwner } from "../../selectors/index.js";
+import {
+  inferDatasetSchema,
+  normalizeSourceSchema,
+  validateRowsAgainstSchema
+} from "../../grammar/datasetSchema.js";
 
-const OPTIONS = Object.freeze(["id", "values"]);
+const OPTIONS = Object.freeze(["id", "values", "schema"]);
 
 export const createData = /* @__PURE__ */ closedAction(
   { op: "createData", description: "Create an immutable named dataset." }, OPTIONS,
@@ -15,12 +20,20 @@ export const createData = /* @__PURE__ */ closedAction(
       ambiguous: this.semanticSpec.datasets.length > 0
     });
     validateDataRows(args.values, "createData");
+    const schema = args.schema === undefined
+      ? inferDatasetSchema(args.values)
+      : normalizeSourceSchema(args.schema);
+    validateRowsAgainstSchema(args.values, schema, "createData");
     if (hasDataset(this, id) || hasDatasetOwner(this, id)) {
       throw new Error(`Dataset "${id}" already exists.`);
     }
-    return this.editSemantic({
-      property: `dataset[${id}].values`,
-      value: args.values
-    });
+    // Keep the historical one-primitive trace for inferred sources. The
+    // semantic primitive owns deterministic inference so a dataset never
+    // exists between actions without its schema.
+    return args.schema === undefined
+      ? this.editSemantic({ property: `dataset[${id}].values`, value: args.values })
+      : this
+        .editSemantic({ property: `dataset[${id}].schema`, value: schema })
+        .editSemantic({ property: `dataset[${id}].values`, value: args.values });
   }
 );

package/src/actions/data/density.js

@@ -6,7 +6,7 @@ import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
   "id", "source", "field", "groupBy", "bandwidth", "extent", "steps",
-  "kernel", "normalization", "as", "weight"
+  "kernel", "normalization", "as", "weight", "missing"
 ]);
 const CATEGORICAL_OPTIONS = Object.freeze([...OPTIONS, "placement"]);
 

package/src/actions/data/derived.js

@@ -11,6 +11,10 @@ import { requireLayer } from "../../selectors/layers.js";
 import { applyLayerDataRematerialization } from
   "../../materialization/dependencies.js";
 import { collectResourceReferences } from "../../core/resourceReferences.js";
+import {
+  assertFieldsAvailable,
+  transformInputFields
+} from "../../grammar/datasetSchema.js";
 
 const OPTIONS = Object.freeze(["id", "source", "transform"]);
 const RELEASE_OPTIONS = Object.freeze(["id"]);
@@ -43,9 +47,16 @@ export const createDerivedData = /* @__PURE__ */ closedAction(
     if (!hasDataset(this, source)) {
       throw new Error(`Unknown source dataset "${source}".`);
     }
-    return this
+    const created = this
       .editSemantic({ property: `dataset[${id}].source`, value: source })
       .editSemantic({ property: `dataset[${id}].transform`, value: args.transform });
+    const input = resolveDatasetReference(created, source, "Source dataset");
+    const transform = args.transform[0];
+    assertFieldsAvailable(input.schema, transformInputFields(transform), {
+      data: input.id,
+      operation: "createDerivedData"
+    });
+    return created;
   }
 );
 
@@ -75,6 +86,9 @@ export const releaseDerivedData = /* @__PURE__ */ closedAction(
       property: `dataset[${validatedId}]`,
       remove: true
     });
+    next = next._withoutMaterializationConfig([
+      "calculations", "datasets", validatedId
+    ]);
     for (const owner of selfOwners) {
       const [, family, ownerId] = owner.path;
       next = next._withoutMaterializationConfig(["data", family, ownerId]);

package/src/actions/data/edit.js

@@ -13,6 +13,8 @@ import {
 } from "../../selectors/datasets.js";
 import { applyLayerDataRematerialization } from
   "../../materialization/dependencies.js";
+import { withLogicalDataReplacements } from
+  "../../materialization/revisionIdentity.js";
 import {
   outputFieldChanges,
   rebindLayerOutputFields,
@@ -36,6 +38,7 @@ const CREATOR_BY_TYPE = Object.freeze({
   interval: "createIntervalData",
   normalize: "createNormalizedData",
   regression: "createRegressionData",
+  sort: "createSortedData",
   stack: "createStackData",
   summary: "createSummaryData",
   timeUnit: "createTimeUnitData",
@@ -54,6 +57,7 @@ const REVISION_ROLE = Object.freeze({
   interval: "IntervalData",
   normalize: "NormalizedData",
   regression: "RegressionData",
+  sort: "SortedData",
   stack: "StackData",
   summary: "SummaryData",
   timeUnit: "TimeUnitData",
@@ -298,6 +302,11 @@ function directLayerConsumers(program, data) {
 }
 
 export function applyRevisionPlan(program, resolved, plan, { retain = new Set() } = {}) {
+  return withLogicalDataReplacements(plan.replacements, () =>
+    applyRevisionPlanWithIdentity(program, resolved, plan, { retain }));
+}
+
+function applyRevisionPlanWithIdentity(program, resolved, plan, { retain }) {
   const root = plan.revisions[0];
   const changes = resolved === undefined ? new Map() : outputFieldChanges(
     resolved.dataset.transform[0],
@@ -464,18 +473,18 @@ export const editComputedData = /* @__PURE__ */ focusedEditor(
   "editComputedData", "computed", ["as", "expression"]
 );
 export const editFilteredData = /* @__PURE__ */ focusedEditor(
-  "editFilteredData", "filter", ["field", "oneOf", "predicate", "range"]
+  "editFilteredData", "filter", ["field", "oneOf", "noneOf", "predicate", "range", "nulls"]
 );
 export const editFoldData = /* @__PURE__ */ focusedEditor(
   "editFoldData", "fold", ["fields", "as"]
 );
 export const editSummaryData = /* @__PURE__ */ focusedEditor(
-  "editSummaryData", "summary", ["groupBy", "aggregates", "members", "weight"]
+  "editSummaryData", "summary", ["groupBy", "aggregates", "members", "weight", "missing", "empty"]
 );
 export const editBinData = /* @__PURE__ */ focusedEditor(
   "editBinData", "bin", [
     "field", "maxBins", "step", "boundaries", "extent", "nice", "zero",
-    "includeEmpty", "members", "as", "weight"
+    "includeEmpty", "members", "as", "weight", "missing"
   ]
 );
 export const editTimeUnitData = /* @__PURE__ */ focusedEditor(
@@ -492,7 +501,7 @@ export const editWindowData = /* @__PURE__ */ focusedEditor(
 export const editDensityData = /* @__PURE__ */ focusedEditor(
   "editDensityData", "density", [
     "field", "groupBy", "bandwidth", "extent", "steps", "kernel",
-    "normalization", "as", "weight"
+    "normalization", "as", "weight", "missing"
   ]
 );
 export const editStackData = /* @__PURE__ */ focusedEditor(
@@ -500,13 +509,16 @@ export const editStackData = /* @__PURE__ */ focusedEditor(
 );
 export const editRegressionData = /* @__PURE__ */ focusedEditor(
   "editRegressionData", "regression", [
-    "x", "y", "groupBy", "method", "degree", "span", "confidenceMethod",
-    "level", "confidence", "interval"
+    "x", "y", "groupBy", "method", "degree", "span", "robustIterations", "confidenceMethod",
+    "level", "confidence", "interval", "predict"
   ]
 );
+export const editSortedData = /* @__PURE__ */ focusedEditor(
+  "editSortedData", "sort", ["sortBy"]
+);
 export const editIntervalData = /* @__PURE__ */ focusedEditor(
   "editIntervalData", "interval", [
-    "field", "groupBy", "center", "extent", "method", "level", "as"
+    "field", "groupBy", "center", "extent", "method", "level", "missing", "as"
   ]
 );
 export const editECDFData = /* @__PURE__ */ focusedEditor(
@@ -543,6 +555,7 @@ export const EDIT_DERIVED_DATA_ACTIONS = Object.freeze({
   editDensityData,
   editStackData,
   editRegressionData,
+  editSortedData,
   editIntervalData,
   editECDFData,
   editNormalizedData,

package/src/actions/data/filter.js

@@ -27,9 +27,14 @@ import {
   resolveEligibleLayer
 } from "../../selectors/index.js";
 import { MATERIALIZE_OPTIONS, requireDerivedDataset } from "./shared.js";
+import {
+  assertFieldsAvailable,
+  deriveTransformSchema,
+  transformInputFields
+} from "../../grammar/datasetSchema.js";
 
 const OPTIONS = Object.freeze([
-  "id", "source", "field", "oneOf", "predicate", "range"
+  "id", "source", "field", "oneOf", "noneOf", "predicate", "range", "nulls"
 ]);
 const MARK_SELECTOR_KEYS = Object.freeze([
   "grain", "field", "channel", "property", "op", "value", "values",
@@ -58,10 +63,16 @@ export const materializeFilteredData = /* @__PURE__ */ closedAction(
       args.id,
       "filter"
     );
-    return this.editSemantic({
-      property: `dataset[${id}].values`,
-      value: deriveFilteredRows(source.values, transform)
+    assertFieldsAvailable(source.schema, transformInputFields(transform), {
+      data: source.id,
+      operation: "materializeFilteredData"
+    });
+    const values = deriveFilteredRows(source.values, transform);
+    const schema = deriveTransformSchema(source.schema, transform, values, {
+      sourceId: source.id,
+      ownerId: id
     });
+    return this.editSemantic({ property: `dataset[${id}].values`, value: values });
   }
 );
 

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

@@ -9,8 +9,9 @@ import { resolveDatasetReference } from "../../selectors/datasets.js";
 import { derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "source", "x", "y", "groupBy", "method", "degree", "span",
+  "id", "source", "x", "y", "groupBy", "method", "degree", "span", "robustIterations",
   "confidenceMethod", "level", "confidence", "interval"
+  , "predict", "missing"
 ]);
 
 export const materializeRegressionData = /* @__PURE__ */ derivedMaterializer(
@@ -24,10 +25,13 @@ export const materializeRegressionData = /* @__PURE__ */ derivedMaterializer(
       method: transform.method,
       degree: transform.degree,
       span: transform.span,
+      robustIterations: transform.robustIterations,
       confidenceMethod: transform.confidenceMethod,
       level: transform.level,
       confidence: transform.confidence,
-      interval: transform.interval
+      interval: transform.interval,
+      predict: transform.predict
+      , missing: transform.missing
     })
 );