ggaction 0.0.16 → 0.0.17

package/src/materialization/text.js

@@ -9,6 +9,7 @@ import { formatTextValue } from "../grammar/text.js";
 import { normalizePositionDatum } from "../grammar/positionDatum.js";
 import { mapOrdinalPositionValues } from "../grammar/scales/index.js";
 import { findDataset } from "../selectors/datasets.js";
+import { applyItemMissingPolicy } from "../grammar/itemMissing.js";
 import { findCoordinate } from "../selectors/coordinates.js";
 import { findLayer } from "../selectors/layers.js";
 import { unionConcreteGraphicBounds } from
@@ -414,10 +415,11 @@ function resolveSourceTextItems(program, layer, config) {
 }
 
 function resolveRowTextItems(program, layer, config) {
-  const dataset = findDataset(program, layer.data);
-  if (dataset === undefined) {
+  const sourceDataset = findDataset(program, layer.data);
+  if (sourceDataset === undefined) {
     throw new Error(`Text mark "${layer.id}" requires an existing dataset.`);
   }
+  const dataset = applyItemMissingPolicy(layer, sourceDataset);
   const encodings = [layer.encoding?.x, layer.encoding?.y, layer.encoding?.text];
   const length = encodings.some(encoding => encoding !== undefined && Object.hasOwn(encoding, "field"))
     ? dataset.values.length

package/src/persistence.js

@@ -5,6 +5,12 @@ import { hasRegisteredExtension, isBuiltinProgramClass } from "./core/extensionR
 import { packageVersion } from "./version.js";
 import { decodeValue, encodeValue, invalidSnapshot } from "./persistence/codec.js";
 import { exactKeys, requireObject, STATE_KEYS, validateGraphic, validateProgramState, validateTrace } from "./persistence/validation.js";
+import {
+  deriveTransformSchema,
+  inferDatasetSchema,
+  validateDatasetSchema
+} from "./grammar/datasetSchema.js";
+import { restoreResolvedScaleBindings } from "./actions/scales/preview.js";
 
 function canonicalState(program, extensions, path = "payload") {
   if (!(program instanceof ChartProgram || program instanceof BasicChartProgram) || !isBuiltinProgramClass(program.constructor)) {
@@ -19,7 +25,7 @@ function canonicalState(program, extensions, path = "payload") {
 }
 
 function envelope(kind, payload, extensions = []) {
-  return JSON.stringify({ schemaVersion: 1, kind, packageVersion, extensions, payload: encodeValue(payload) });
+  return JSON.stringify({ schemaVersion: kind === "editable" ? 2 : 1, kind, packageVersion, extensions, payload: encodeValue(payload) });
 }
 
 function readEnvelope(text, kind) {
@@ -27,7 +33,13 @@ function readEnvelope(text, kind) {
   let value;
   try { value = JSON.parse(text); } catch { throw invalidSnapshot("Snapshot must be valid JSON.", "snapshot"); }
   exactKeys(value, ["schemaVersion", "kind", "packageVersion", "extensions", "payload"], "snapshot");
-  if (value.schemaVersion !== 1 || value.kind !== kind) throw invalidSnapshot(`Unsupported snapshot schema or kind; expected schema 1 ${kind}.`, "snapshot");
+  const versions = kind === "editable" ? [1, 2] : [1];
+  if (!versions.includes(value.schemaVersion) || value.kind !== kind) {
+    throw invalidSnapshot(
+      `Unsupported snapshot schema or kind; expected schema ${versions.join(" or ")} ${kind}.`,
+      "snapshot"
+    );
+  }
   if (typeof value.packageVersion !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(value.packageVersion)) throw invalidSnapshot("Invalid snapshot packageVersion.", "snapshot.packageVersion");
   if (!Array.isArray(value.extensions) || new Set(value.extensions).size !== value.extensions.length ||
       value.extensions.some(name => typeof name !== "string" || !hasRegisteredExtension(name)) || (kind === "graphic" && value.extensions.length)) {
@@ -36,15 +48,69 @@ function readEnvelope(text, kind) {
   return { ...value, payload: decodeValue(value.payload) };
 }
 
-function restoreState(state, extensions, path = "payload") {
+function restoreState(state, extensions, path = "payload", { requireSchemas = false } = {}) {
   exactKeys(state, STATE_KEYS, path);
   if (!Array.isArray(state.actionStack) || state.actionStack.length) throw invalidSnapshot("Snapshot actionStack must be empty.", `${path}.actionStack`);
   requireObject(state.children, `${path}.children`);
   validateTrace(state.trace, ChartProgram, extensions, `${path}.trace`);
-  const children = Object.fromEntries(Object.entries(state.children).map(([id, child]) => [id, restoreState(child, extensions, `${path}.children.${id}`)]));
+  const children = Object.fromEntries(Object.entries(state.children).map(([id, child]) => [id, restoreState(
+    child,
+    extensions,
+    `${path}.children.${id}`,
+    { requireSchemas }
+  )]));
   const program = new ChartProgram({ ...state, children });
   validateProgramState(program, path);
-  return program;
+  if (requireSchemas) {
+    for (const dataset of program.semanticSpec.datasets) {
+      if (dataset.schema === undefined) {
+        throw invalidSnapshot(`Dataset "${dataset.id}" requires schema in editable snapshot version 2.`, `${path}.semanticSpec.datasets`);
+      }
+      validateDatasetSchema(dataset.schema);
+    }
+  }
+  return restoreResolvedScaleBindings(program);
+}
+
+function migrateStateSchemas(state) {
+  const datasets = state.semanticSpec.datasets;
+  const byId = new Map(datasets.map(dataset => [dataset.id, dataset]));
+  const schemas = new Map();
+  const active = new Set();
+  function schemaFor(id) {
+    if (schemas.has(id)) return schemas.get(id);
+    if (active.has(id)) throw invalidSnapshot(`Cyclic data source "${id}".`, "payload.semanticSpec.datasets");
+    active.add(id);
+    const dataset = byId.get(id);
+    let schema;
+    if (dataset.schema !== undefined) {
+      schema = validateDatasetSchema(dataset.schema);
+    } else if (dataset.source === undefined) {
+      schema = inferDatasetSchema(dataset.values ?? []);
+    } else {
+      const sourceSchema = schemaFor(dataset.source);
+      schema = deriveTransformSchema(
+        sourceSchema,
+        dataset.transform?.[0] ?? {},
+        dataset.values,
+        { sourceId: dataset.source, ownerId: dataset.id }
+      );
+    }
+    active.delete(id);
+    schemas.set(id, schema);
+    return schema;
+  }
+  const semanticSpec = {
+    ...state.semanticSpec,
+    datasets: datasets.map(dataset => ({ ...dataset, schema: schemaFor(dataset.id) }))
+  };
+  return {
+    ...state,
+    semanticSpec,
+    children: Object.fromEntries(Object.entries(state.children).map(
+      ([id, child]) => [id, migrateStateSchemas(child)]
+    ))
+  };
 }
 
 export function serializeProgram(program) {
@@ -55,7 +121,14 @@ export function serializeProgram(program) {
 export function deserializeProgram(text) {
   const stored = readEnvelope(text, "editable");
   const extensions = new Set();
-  const program = restoreState(stored.payload, extensions);
+  let payload = stored.payload;
+  if (stored.schemaVersion === 1) {
+    // Validate the historical state before adding any inferred metadata. Migration
+    // must never repair an invalid reference graph or malformed payload.
+    restoreState(payload, new Set());
+    payload = migrateStateSchemas(payload);
+  }
+  const program = restoreState(payload, extensions, "payload", { requireSchemas: true });
   if (extensions.size !== stored.extensions.length || stored.extensions.some(name => !extensions.has(name))) {
     throw invalidSnapshot("Snapshot extensions must exactly match its action traces.", "snapshot.extensions");
   }

package/src/version.js

@@ -1,2 +1,2 @@
 // Must match package.json; enforced by the snapshot producer-version test.
-export const packageVersion = "0.0.16";
+export const packageVersion = "0.0.17";

package/types/inspection.d.ts

@@ -0,0 +1,17 @@
+import type { BasicChartProgram } from "./basic.js";
+import type { ChartProgram, DatasetSchema } from "./program.js";
+export type ProgramInput = ChartProgram | BasicChartProgram;
+export interface ResourceRef { readonly kind: "data" | "mark" | "scale" | "coordinate" | "guide" | "canvas" | "composition"; readonly id: string; readonly childPath?: readonly string[]; }
+export interface InspectionTarget { readonly kind: "data" | "mark" | "scale" | "coordinate" | "guide"; readonly id: string; readonly childPath?: readonly string[]; }
+export interface Finding { readonly severity: "error" | "warning" | "info"; readonly code: string; readonly reason: string; readonly message: string; readonly resource?: ResourceRef; readonly optionPath?: string; }
+export interface CheckResult { readonly name: string; readonly status: "not_run" | "passed" | "failed" | "not_applicable"; readonly evidencePaths: readonly string[]; readonly findings: readonly Finding[]; }
+export interface ParameterDefinition { readonly path: string; readonly kind: "field" | "enum" | "number" | "string" | "boolean" | "range" | "array" | "object" | "resource"; readonly required: boolean; readonly active: boolean; readonly choices?: readonly (string | number | boolean | null)[]; readonly minimum?: number; readonly maximum?: number; readonly unit?: string; readonly fieldRole?: string; }
+export interface ActionDescription { readonly version: 1; readonly action: string; readonly applicability: "supported" | "needs-input" | "incompatible" | "unsupported" | "unverified"; readonly parameterDefinitions: readonly ParameterDefinition[]; readonly requirements: readonly { readonly reason: string; readonly optionPath?: string }[]; readonly checks: readonly CheckResult[]; readonly findings: readonly Finding[]; }
+export interface Change { readonly resource: ResourceRef; readonly operation: "add" | "remove" | "modify"; readonly effect: "data" | "binding" | "structure" | "scale" | "guide" | "style"; readonly roles: readonly string[]; }
+export interface ProgramComparison { readonly version: 1; readonly equivalence: "equal" | "different" | "unknown"; readonly completeProgramComparison: boolean; readonly changes: readonly Change[]; readonly affected: readonly ResourceRef[]; readonly findings: readonly Finding[]; }
+export interface OwnerInspection { readonly owner: ResourceRef; readonly grain: "item" | "series" | "composite" | "unknown"; readonly rawRows: number | null; readonly logicalDataItems: number | null; readonly drawablePrimitives: number | null; readonly visibleCandidates: number | null; readonly flags: readonly { readonly reason: "opacity-zero" | "zero-size" | "outside-clip" | "missing-skipped"; readonly count: number | null }[]; readonly bounds: Readonly<{x:number;y:number;width:number;height:number}> | null; readonly sourceRefs: readonly ResourceRef[]; readonly checks: readonly CheckResult[]; }
+export interface ProgramInspection { readonly version: 1; readonly views: readonly OwnerInspection[]; readonly calculations: readonly unknown[]; readonly checks: readonly CheckResult[]; readonly findings: readonly Finding[]; readonly coverage: Readonly<{partial:boolean;unsupported:readonly ResourceRef[]}>; }
+export function getDatasetSchema(program: ProgramInput, options: {readonly data:string;readonly childPath?:readonly string[]}): Readonly<{data:string;schema:DatasetSchema}>;
+export function describeAction(program: ProgramInput, options: {readonly action:string;readonly target?:InspectionTarget;readonly options?:Readonly<Record<string,unknown>>}): ActionDescription;
+export function comparePrograms(before: ProgramInput, after: ProgramInput, options?: {readonly target?:InspectionTarget}): ProgramComparison;
+export function inspectProgram(program: ProgramInput, options?: {readonly target?:InspectionTarget}): ProgramInspection;

package/types/program.d.ts

@@ -339,21 +339,29 @@ export type DensityPlacement =
 export type FilterComparison =
   | { op: "eq" | "neq"; value: unknown }
   | { op: "lt" | "lte" | "gt" | "gte"; value: number | string };
-export type FilterRange = {
-  min: number | string;
-  max: number | string;
-  inclusive?: boolean;
-};
+type FilterBound = number | string;
+type FilterRangeBounds =
+  | { min: FilterBound; max?: FilterBound }
+  | { min?: FilterBound; max: FilterBound };
+type FilterRangeClosure =
+  | { inclusive?: boolean; minInclusive?: never; maxInclusive?: never }
+  | { inclusive?: never; minInclusive?: boolean; maxInclusive?: boolean };
+export type FilterRange = FilterRangeBounds & FilterRangeClosure;
 export type FilterModeOptions =
-  | { oneOf: readonly unknown[]; predicate?: never; range?: never }
-  | { oneOf?: never; predicate: FilterComparison; range?: never }
-  | { oneOf?: never; predicate?: never; range: FilterRange };
+  | { oneOf: readonly [DatasetScalar, ...DatasetScalar[]]; noneOf?: never; predicate?: never; range?: never }
+  | { oneOf?: never; noneOf: readonly [DatasetScalar, ...DatasetScalar[]]; predicate?: never; range?: never }
+  | { oneOf?: never; noneOf?: never; predicate: FilterComparison; range?: never }
+  | { oneOf?: never; noneOf?: never; predicate?: never; range: FilterRange };
 export type FilterDataOptions = {
   id: string;
   source?: string;
   field: string;
+  nulls?: "include" | "exclude";
 } & FilterModeOptions;
 export type DatasetScalar = string | number | boolean | null;
+export type RegressionPredictOptions =
+  | { values: readonly [number, ...number[]]; domain?: never; steps?: never }
+  | { values?: never; domain: readonly [number, number]; steps: number };
 export type DisplayLabelMap = ReadonlyArray<Readonly<{
   value: DatasetScalar;
   label: string;
@@ -364,10 +372,12 @@ export interface DisplayLabelOptions {
 export type DatasetFilterTransform = {
   type: "filter";
   field: string;
+  nulls?: "include" | "exclude";
 } & (
-  | { oneOf: readonly DatasetScalar[]; predicate?: never; range?: never }
-  | { oneOf?: never; predicate: FilterComparison; range?: never }
-  | { oneOf?: never; predicate?: never; range: FilterRange }
+  | { oneOf: readonly DatasetScalar[]; noneOf?: never; predicate?: never; range?: never }
+  | { oneOf?: never; noneOf: readonly DatasetScalar[]; predicate?: never; range?: never }
+  | { oneOf?: never; noneOf?: never; predicate: FilterComparison; range?: never }
+  | { oneOf?: never; noneOf?: never; predicate?: never; range: FilterRange }
 );
 export type DatasetRegressionTransform = {
   type: "regression";
@@ -375,24 +385,22 @@ export type DatasetRegressionTransform = {
   y: string;
   groupBy?: string;
 } & (
-  | {
+  | ({
       method: "linear";
-      interval: "mean" | "prediction";
       degree?: never;
       span?: never;
-    } & (
+    } & ({ interval: false; confidenceMethod?: never; level?: never; confidence?: never } | ({ interval: "mean" | "prediction" } & (
       | { confidenceMethod: ConfidenceIntervalMethod; level: number; confidence?: never }
       | { confidence: number; confidenceMethod?: never; level?: never }
-    )
-  | {
+    ))))
+  | ({
       method: "polynomial";
       degree: number;
-      interval: "mean" | "prediction";
       span?: never;
-    } & (
+    } & ({ interval: false; confidenceMethod?: never; level?: never; confidence?: never } | ({ interval: "mean" | "prediction" } & (
       | { confidenceMethod: ConfidenceIntervalMethod; level: number; confidence?: never }
       | { confidence: number; confidenceMethod?: never; level?: never }
-    )
+    ))))
   | {
       method: "loess";
       span: number;
@@ -402,7 +410,7 @@ export type DatasetRegressionTransform = {
       confidence?: never;
       interval?: never;
     }
-);
+) & { readonly predict?: RegressionPredictOptions; readonly missing?: "error" | "drop" };
 export interface DatasetDensityTransform {
   type: "density";
   field: string;
@@ -413,6 +421,7 @@ export interface DatasetDensityTransform {
   kernel?: DensityKernel;
   normalization?: DensityNormalization;
   weight?: StatisticalWeight;
+  missing?: "error" | "drop";
   as: readonly [string, string];
   resolve: "shared";
   placement?: {
@@ -500,6 +509,7 @@ export type DatasetIntervalTransform = {
   field: string;
   groupBy: readonly string[];
   as: DatasetIntervalOutputFields;
+  missing?: "error" | "drop";
 } & (
   | {
       center: "mean";
@@ -603,6 +613,21 @@ export interface DatasetWindowTransform {
   readonly operations: readonly DatasetWindowOperation[];
   readonly temporalUnit?: TemporalInputUnit;
 }
+export interface SortKey {
+  field: string;
+  order?: "ascending" | "descending";
+  nulls?: "first" | "last";
+  temporalUnit?: "year" | "timestamp";
+}
+export interface DatasetSortTransform {
+  readonly type: "sort";
+  readonly sortBy: readonly {
+    readonly field: string;
+    readonly order: "ascending" | "descending";
+    readonly nulls: "first" | "last";
+    readonly temporalUnit?: "year" | "timestamp";
+  }[];
+}
 export interface ECDFOutputFields {
   value: string;
   cumulative: string;
@@ -715,6 +740,7 @@ export interface DatasetBinTransform {
   readonly includeEmpty: boolean;
   readonly members: boolean;
   readonly weight?: StatisticalWeight;
+  readonly missing?: "error" | "drop";
   readonly as: {
     readonly lower: string;
     readonly upper: string;
@@ -871,6 +897,7 @@ export type DatasetTransform =
   | DatasetFilterTransform
   | DatasetFoldTransform
   | DatasetRegressionTransform
+  | DatasetSortTransform
   | DatasetDensityTransform
   | DatasetECDFTransform
   | DatasetHorizonTransform
@@ -902,6 +929,8 @@ export interface DatasetSummaryTransform {
   aggregates: readonly SummaryAggregateOptions[];
   members?: string;
   weight?: StatisticalWeight;
+  missing?: "error" | "drop";
+  empty?: "null" | "identity";
 }
 export interface SummaryAggregateOptions {
   op: AggregateOperation;
@@ -915,6 +944,18 @@ export interface SummaryDataOptions {
   aggregates: readonly SummaryAggregateOptions[];
   members?: string;
   weight?: StatisticalWeight;
+  missing?: "error" | "drop";
+  empty?: "null" | "identity";
+}
+export interface SortedDataOptions {
+  id: string;
+  source?: string;
+  sortBy: readonly [SortKey, ...SortKey[]];
+}
+export interface EditSortedDataOptions {
+  target: string;
+  sortBy: readonly [SortKey, ...SortKey[]];
+  dependents?: DerivedDataDependents;
 }
 export interface BindMarkDataOptions {
   target: string;
@@ -1094,19 +1135,57 @@ export interface TraceNode {
 
 export interface SemanticDataset {
   readonly id: string;
+  readonly schema: DatasetSchema;
   readonly values?: readonly Readonly<Record<string, unknown>>[];
   readonly source?: string;
   readonly transform?: readonly Readonly<Record<string, unknown>>[];
   readonly [key: string]: unknown;
 }
 
+export type DatasetStorageType =
+  | "number"
+  | "string"
+  | "boolean"
+  | "array"
+  | "object"
+  | "unknown"
+  | "mixed";
+export interface DatasetFieldLineage {
+  readonly inputs: readonly Readonly<{ data: string; field: string }>[];
+  readonly owner: string;
+  readonly role: string;
+}
+export interface DatasetSchemaField {
+  readonly name: string;
+  readonly storageType: DatasetStorageType;
+  readonly nullable: boolean;
+  readonly optional: boolean;
+  readonly lineage?: DatasetFieldLineage;
+}
+export interface DatasetSchema {
+  readonly version: 1;
+  readonly completeness: "known" | "unknown";
+  readonly origin: "declared" | "inferred" | "derived";
+  readonly fields: readonly DatasetSchemaField[];
+}
+export interface SourceSchemaField {
+  name: string;
+  storageType: Exclude<DatasetStorageType, "unknown" | "mixed">;
+  nullable?: boolean;
+  optional?: boolean;
+}
+export interface SourceSchemaInput {
+  fields: readonly SourceSchemaField[];
+}
+
 export interface SemanticLayer {
   readonly id: string;
   readonly data?: string;
   readonly source?: string;
   readonly coordinate?: string;
-  readonly mark?: Readonly<{ type?: string; missing?: "error" | "break"; [key: string]: unknown }>;
+  readonly mark?: Readonly<{ type?: string; missing?: "error" | "break" | "skip"; [key: string]: unknown }>;
   readonly layout?: Readonly<{ mode?: ColorLayout }>;
+  readonly derivedBindings?: Readonly<{ regression?: Readonly<{ mode: "follow"; roles: readonly ["data", "x", "y"] }> }>;
   readonly encoding?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
   readonly [key: string]: unknown;
 }
@@ -1115,6 +1194,7 @@ export interface SemanticScale {
   readonly id: string;
   readonly type?: ScaleType;
   readonly domain?: "auto" | readonly unknown[];
+  readonly emptyDomain?: "preserve" | "require-explicit";
   readonly range?: ScaleRange;
   readonly [key: string]: unknown;
 }
@@ -1557,6 +1637,7 @@ export interface ScaleOptions {
   id?: string;
   type?: ScaleType;
   domain?: "auto" | readonly unknown[];
+  emptyDomain?: "preserve" | "require-explicit";
   range?: ScaleRange;
   nice?: boolean;
   zero?: boolean;
@@ -1702,6 +1783,7 @@ export interface EditScaleOptions {
   id?: string;
   type?: ScaleType;
   domain?: "auto" | readonly unknown[];
+  emptyDomain?: "preserve" | "require-explicit";
   range?: ScaleRange;
   nice?: boolean;
   zero?: boolean;
@@ -2017,6 +2099,7 @@ export interface DensityDataOptions {
   kernel?: DensityKernel;
   normalization?: DensityNormalization;
   weight?: StatisticalWeight;
+  missing?: "error" | "drop";
   as?: readonly [string, string];
 }
 
@@ -2112,6 +2195,7 @@ export interface IntervalDataOptions {
   extent?: IntervalExtent;
   method?: ConfidenceIntervalMethod;
   level?: number;
+  missing?: "error" | "drop";
   as?: IntervalOutputFields;
 }
 
@@ -2184,6 +2268,7 @@ export type BinDataOptions = {
   includeEmpty?: boolean;
   members?: boolean;
   weight?: StatisticalWeight;
+  missing?: "error" | "drop";
   as?: BinDataOutputFields;
 } & BinDataMode;
 
@@ -2326,7 +2411,22 @@ type FocusedWeightedDerivedDataEdit<T, Weight> = {
   : never);
 
 export type EditComputedDataOptions = FocusedDerivedDataEdit<ComputedDataOptions>;
-export type EditFilteredDataOptions = FocusedDerivedDataEdit<FilterDataOptions>;
+export type FilterRangePatch = FilterRangeClosure & {
+  min?: FilterBound | false;
+  max?: FilterBound | false;
+};
+type FilterModePatch =
+  | { oneOf: readonly [DatasetScalar, ...DatasetScalar[]]; noneOf?: never; predicate?: never; range?: never }
+  | { oneOf?: never; noneOf: readonly [DatasetScalar, ...DatasetScalar[]]; predicate?: never; range?: never }
+  | { oneOf?: never; noneOf?: never; predicate: FilterComparison; range?: never }
+  | { oneOf?: never; noneOf?: never; predicate?: never; range: FilterRangePatch }
+  | { oneOf?: never; noneOf?: never; predicate?: never; range?: never };
+export type EditFilteredDataOptions = FilterModePatch & {
+  target: string;
+  field?: string;
+  nulls?: "include" | "exclude" | false;
+  dependents?: DerivedDataDependents;
+};
 export type EditFoldDataOptions = FocusedDerivedDataEdit<FoldDataOptions>;
 export type EditSummaryDataOptions = FocusedWeightedDerivedDataEdit<
   SummaryDataOptions,
@@ -3690,6 +3790,7 @@ export interface TextMarkOptions {
   /** Explicit source mark. Mutually exclusive with data; may be incomplete. */
   source?: string;
   text?: unknown;
+  missing?: "error" | "skip";
   fill?: string;
   opacity?: number;
   fontSize?: number;
@@ -3753,6 +3854,7 @@ export interface RemoveLabelLayoutOptions {
 export interface RectMarkOptions extends RectStyleDetails {
   id?: string;
   data?: string;
+  missing?: "error" | "skip";
   fill?: string;
   opacity?: number;
   stroke?: string | false;
@@ -4160,7 +4262,8 @@ type RegressionParameterOptions =
       confidenceMethod?: ConfidenceIntervalMethod;
       level?: number;
       confidence?: number;
-      interval?: RegressionInterval;
+      interval?: RegressionInterval | false;
+      predict?: RegressionPredictOptions;
     }
   | {
       method: "polynomial";
@@ -4169,7 +4272,8 @@ type RegressionParameterOptions =
       confidenceMethod?: ConfidenceIntervalMethod;
       level?: number;
       confidence?: number;
-      interval?: RegressionInterval;
+      interval?: RegressionInterval | false;
+      predict?: RegressionPredictOptions;
     }
   | {
       method: "loess";
@@ -4179,6 +4283,7 @@ type RegressionParameterOptions =
       level?: never;
       confidence?: never;
       interval?: never;
+      predict?: RegressionPredictOptions;
     };
 
 export type RegressionDataOptions = {
@@ -4187,6 +4292,7 @@ export type RegressionDataOptions = {
   x: string;
   y: string;
   groupBy?: string;
+  missing?: "error" | "drop";
 } & RegressionParameterOptions;
 
 type RegressionCommonOptions = {
@@ -4195,6 +4301,8 @@ type RegressionCommonOptions = {
   y?: string;
   groupBy?: string | false;
   line?: StrokeStyleDetails & { strokeWidth?: number; curve?: CurveInterpolation };
+  sourceBinding?: "fixed" | "follow";
+  missing?: "error" | "drop";
 };
 
 export type RegressionOptions = RegressionCommonOptions & (
@@ -4221,9 +4329,12 @@ export interface EditRegressionOptions {
   confidenceMethod?: ConfidenceIntervalMethod;
   level?: number;
   confidence?: number;
-  interval?: RegressionInterval;
+  interval?: RegressionInterval | false;
+  missing?: "error" | "drop";
+  predict?: RegressionPredictOptions | false;
   band?: false | RegressionBandOptions;
   line?: StrokeStyleDetails & { strokeWidth?: number; curve?: CurveInterpolation };
+  sourceBinding?: "fixed" | "follow";
 }
 
 export interface RemoveAxisOptions {
@@ -4497,6 +4608,7 @@ type StoredCell<T> = T extends (...args: never[]) => unknown ? never
 export interface CreateDataOptions<Row extends object> {
   id?: string;
   values: readonly (Row extends readonly unknown[] ? never : Row & StoredCell<Row>)[];
+  schema?: SourceSchemaInput;
 }
 
 export interface ReviseDataOptions<Row extends object> extends CreateDataOptions<Row> {
@@ -4552,6 +4664,7 @@ export class ChartProgram {
   createTimeUnitData(options: TimeUnitDataOptions): ChartProgram;
   createWindowData(options: WindowDataOptions): ChartProgram;
   createBin2DData(options: Bin2DDataOptions): ChartProgram;
+  createSortedData(options: SortedDataOptions): ChartProgram;
   editDerivedData(options: EditDerivedDataOptions): ChartProgram;
   editComputedData(options: EditComputedDataOptions): ChartProgram;
   editFilteredData(options: EditFilteredDataOptions): ChartProgram;
@@ -4563,6 +4676,7 @@ export class ChartProgram {
   editDensityData(options: EditDensityDataOptions): ChartProgram;
   editStackData(options: EditStackDataOptions): ChartProgram;
   editRegressionData(options: EditRegressionDataOptions): ChartProgram;
+  editSortedData(options: EditSortedDataOptions): ChartProgram;
   editIntervalData(options: EditIntervalDataOptions): ChartProgram;
   editECDFData(options: EditECDFDataOptions): ChartProgram;
   editNormalizedData(options: EditNormalizedDataOptions): ChartProgram;
@@ -4573,6 +4687,7 @@ export class ChartProgram {
   createPointMark(options?: StrokeStyleDetails & {
     id?: string;
     data?: string;
+    missing?: "error" | "skip";
     shape?: PointShape;
     fill?: string;
     opacity?: number;
@@ -4581,6 +4696,7 @@ export class ChartProgram {
   }): ChartProgram;
   editPointMark(options: StrokeStyleDetails & {
     target?: string;
+    missing?: "error" | "skip";
     shape?: PointShape;
     fill?: string;
     opacity?: number;
@@ -4590,6 +4706,7 @@ export class ChartProgram {
   createTickMark(options?: StrokeStyleDetails & {
     id?: string;
     data?: string;
+    missing?: "error" | "skip";
     length?: number;
     stroke?: string;
     strokeWidth?: number;
@@ -4597,6 +4714,7 @@ export class ChartProgram {
   }): ChartProgram;
   editTickMark(options: StrokeStyleDetails & {
     target?: string;
+    missing?: "error" | "skip";
     length?: number;
     stroke?: string;
     strokeWidth?: number;
@@ -4626,6 +4744,7 @@ export class ChartProgram {
   createBarMark(options?: RectStyleDetails & {
     id?: string;
     data?: string;
+    missing?: "error" | "skip";
     fill?: string;
     opacity?: number;
     stroke?: FilledMarkStroke;
@@ -4633,6 +4752,7 @@ export class ChartProgram {
   }): ChartProgram;
   editBarMark(options: RectStyleDetails & {
     target?: string;
+    missing?: "error" | "skip";
     fill?: string;
     opacity?: number;
     stroke?: FilledMarkStroke;
@@ -4669,8 +4789,8 @@ export class ChartProgram {
   }): ChartProgram;
   createRectMark(options?: RectMarkOptions): ChartProgram;
   editRectMark(options: EditRectMarkOptions): ChartProgram;
-  createRuleMark(options?: { id?: string; data?: string } & RuleStyleOptions): ChartProgram;
-  editRuleMark(options: { target?: string } & RuleStyleOptions): ChartProgram;
+  createRuleMark(options?: { id?: string; data?: string; missing?: "error" | "skip" } & RuleStyleOptions): ChartProgram;
+  editRuleMark(options: { target?: string; missing?: "error" | "skip" } & RuleStyleOptions): ChartProgram;
   createTextMark(options?: TextMarkOptions): ChartProgram;
   createMarkLabels(options?: CreateMarkLabelsOptions): ChartProgram;
   editMarkLabelSelection(options: EditMarkLabelSelectionOptions): ChartProgram;