ggaction 0.0.15 → 0.0.17

package/src/actions/data/complete.js

@@ -8,14 +8,14 @@ const OPTIONS = Object.freeze([
   "id", "source", "key", "groupBy", "values", "sequence", "fill", "members"
 ]);
 
-export const materializeCompleteData = derivedMaterializer(
+export const materializeCompleteData = /* @__PURE__ */ derivedMaterializer(
   "materializeCompleteData",
   "Materialize one immutable completed-key dataset.",
   "complete",
   deriveCompleteRows
 );
 
-export const createCompleteData = derivedCreator(
+export const createCompleteData = /* @__PURE__ */ derivedCreator(
   "createCompleteData",
   "Complete one key domain independently within observed groups.",
   OPTIONS,

package/src/actions/data/computed.js

@@ -6,14 +6,14 @@ import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze(["id", "source", "as", "expression"]);
 
-export const materializeComputedData = derivedMaterializer(
+export const materializeComputedData = /* @__PURE__ */ derivedMaterializer(
   "materializeComputedData",
   "Materialize one immutable row-level typed expression dataset.",
   "computed",
   deriveComputedRows
 );
 
-export const createComputedData = derivedCreator(
+export const createComputedData = /* @__PURE__ */ derivedCreator(
   "createComputedData",
   "Create a typed computed field from a closed expression.",
   OPTIONS,

package/src/actions/data/create.js

@@ -1,33 +1,39 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { resolveOptionalUserId } from "../../core/identifiers.js";
-import { isPlainObject } from "../../core/immutable.js";
-import { validateKeys } from "../../core/validation.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 = action(
-  { op: "createData", description: "Create an immutable named dataset." },
+export const createData = /* @__PURE__ */ closedAction(
+  { op: "createData", description: "Create an immutable named dataset." }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "createData");
     const id = resolveOptionalUserId(args.id, {
       defaultId: "data",
       label: "Dataset id",
       operation: "createData",
       ambiguous: this.semanticSpec.datasets.length > 0
     });
-    if (!Array.isArray(args.values)) {
-      throw new TypeError("createData requires values to be an array.");
-    }
-    if (!args.values.every(isPlainObject)) {
-      throw new TypeError("createData requires every row to be a plain object.");
-    }
+    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"]);
 
@@ -25,7 +25,7 @@ function requestedTransform(args, op, categorical = false) {
   });
 }
 
-export const materializeDensityData = derivedMaterializer(
+export const materializeDensityData = /* @__PURE__ */ derivedMaterializer(
   "materializeDensityData",
   "Materialize one grouped kernel-density dataset.",
   "density",
@@ -44,7 +44,7 @@ export const materializeDensityData = derivedMaterializer(
   }]
 );
 
-export const createDensityData = derivedCreator(
+export const createDensityData = /* @__PURE__ */ derivedCreator(
   "createDensityData",
   "Create grouped kernel-density values.",
   OPTIONS,
@@ -54,7 +54,7 @@ export const createDensityData = derivedCreator(
   "materializeDensityData"
 );
 
-export const createCategoricalDensityData = derivedCreator(
+export const createCategoricalDensityData = /* @__PURE__ */ derivedCreator(
   "createCategoricalDensityData",
   "Create category-placed kernel-density values.",
   CATEGORICAL_OPTIONS,

package/src/actions/data/derived.js

@@ -1,6 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
+
 import {
   findDataset,
   hasDataset,
@@ -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"]);
@@ -27,10 +31,9 @@ const OWNED_MARK_ROLES = Object.freeze([
   "statisticalReference"
 ]);
 
-export const createDerivedData = action(
-  { op: "createDerivedData", description: "Create an immutable derived dataset definition." },
+export const createDerivedData = /* @__PURE__ */ closedAction(
+  { op: "createDerivedData", description: "Create an immutable derived dataset definition." }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "createDerivedData");
     const id = validateUserId(args.id, "Derived dataset id");
     const requestedSource = validateUserId(args.source, "Source dataset id");
     const source = resolveDatasetReference(
@@ -44,19 +47,25 @@ export const createDerivedData = action(
     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;
   }
 );
 
-export const releaseDerivedData = action(
+export const releaseDerivedData = /* @__PURE__ */ closedAction(
   {
     op: "releaseDerivedData",
     description: "Release one unreferenced derived dataset."
-  },
+  }, RELEASE_OPTIONS,
   function (args = {}) {
-    validateKeys(args, RELEASE_OPTIONS, "releaseDerivedData");
     const validatedId = validateUserId(args.id, "Derived dataset id");
     const dataset = findDataset(this, validatedId);
     if (dataset === undefined || dataset.source === undefined) {
@@ -77,6 +86,9 @@ export const releaseDerivedData = action(
       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]);
@@ -85,13 +97,12 @@ export const releaseDerivedData = action(
   }
 );
 
-export const rebindLayerData = action(
+export const rebindLayerData = /* @__PURE__ */ closedAction(
   {
     op: "rebindLayerData",
     description: "Rebind one semantic layer to an existing dataset."
-  },
+  }, REBIND_OPTIONS,
   function (args = {}) {
-    validateKeys(args, REBIND_OPTIONS, "rebindLayerData");
     const id = validateUserId(args.id, "Layer id");
     const requestedData = validateUserId(args.data, "Layer dataset id");
     const data = resolveDatasetReference(
@@ -134,13 +145,12 @@ function applyMarkDataBinding(program, target, data) {
   return applyLayerDataRematerialization(rebound, target);
 }
 
-export const bindMarkData = action(
+export const bindMarkData = /* @__PURE__ */ closedAction(
   {
     op: "bindMarkData",
     description: "Atomically bind one independent mark to materialized data."
-  },
+  }, BIND_OPTIONS,
   function (args = {}) {
-    validateKeys(args, BIND_OPTIONS, "bindMarkData");
     const target = validateUserId(args.target, "Mark target id");
     const requestedData = validateUserId(args.data, "Mark dataset id");
     const data = resolveDatasetReference(

package/src/actions/data/ecdf.js

@@ -9,7 +9,7 @@ const OPTIONS = Object.freeze([
   "id", "source", "field", "groupBy", "weight", "missing", "as"
 ]);
 
-export const materializeECDFData = derivedMaterializer(
+export const materializeECDFData = /* @__PURE__ */ derivedMaterializer(
   "materializeECDFData",
   "Materialize one empirical cumulative distribution dataset.",
   "ecdf",
@@ -17,7 +17,7 @@ export const materializeECDFData = derivedMaterializer(
   resolveECDFTransform
 );
 
-export const createECDFData = derivedCreator(
+export const createECDFData = /* @__PURE__ */ derivedCreator(
   "createECDFData",
   "Create immutable empirical cumulative distribution values.",
   OPTIONS,

package/src/actions/data/edit.js

@@ -1,4 +1,4 @@
-import { action } from "../../core/action.js";
+import { action, closedAction } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateKeys } from "../../core/validation.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",
@@ -254,7 +258,7 @@ function buildRevisionPlan(
       `Derived dataset "${resolved.owner}" cannot use one of its dependents as source.`
     );
   }
-  const reserved = new Set();
+  const reserved = new Set(resolved.revision === undefined ? [] : [resolved.revision]);
   const revisions = [];
   const replacements = new Map();
   const add = (dataset, ownerRecord, transform, requestedSource) => {
@@ -274,7 +278,12 @@ function buildRevisionPlan(
     revisions.push(revision);
     replacements.set(dataset.id, id);
   };
-  add(resolved.dataset, resolved, definition, rootSource);
+  if (resolved.revision === undefined) {
+    add(resolved.dataset, resolved, definition, rootSource);
+  } else {
+    revisions.push({ old: resolved.current, id: resolved.revision });
+    replacements.set(resolved.current, resolved.revision);
+  }
   if (dependents === "recompute") {
     for (const dataset of downstream) {
       const policy = findTransformPolicy(dataset.transform[0].type);
@@ -292,14 +301,20 @@ function directLayerConsumers(program, data) {
     .map(layer => layer.id);
 }
 
-function applyRevisionPlan(program, resolved, plan) {
+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 = outputFieldChanges(
+  const changes = resolved === undefined ? new Map() : outputFieldChanges(
     resolved.dataset.transform[0],
     root.transform
   );
   let next = program;
   for (const revision of plan.revisions) {
+    if (revision.transform === undefined) continue;
     const policy = findTransformPolicy(revision.transform.type);
     next = next.createDerivedData({
       id: revision.id,
@@ -345,6 +360,7 @@ function applyRevisionPlan(program, resolved, plan) {
     next = applyLayerDataRematerialization(next, consumer.id);
   }
   for (const revision of [...plan.revisions].reverse()) {
+    if (retain.has(revision.old)) continue;
     next = next.releaseDerivedData({ id: revision.old });
   }
 
@@ -353,6 +369,12 @@ function applyRevisionPlan(program, resolved, plan) {
   return next._withContext({ ...program.context, currentData });
 }
 
+export function buildSourceRevisionPlan(program, source, id) {
+  return buildRevisionPlan(program, {
+    current: source, dataset: findDataset(program, source), revision: id
+  }, undefined, "recompute");
+}
+
 function sameRequested(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
@@ -375,13 +397,12 @@ export function reviseDerivedData(program, {
   return applyRevisionPlan(program, resolved, plan);
 }
 
-export const editDerivedData = action(
+export const editDerivedData = /* @__PURE__ */ closedAction(
   {
     op: "editDerivedData",
     description: "Atomically revise one standalone derived-data definition."
-  },
+  }, GENERIC_OPTIONS,
   function (args = {}) {
-    validateKeys(args, GENERIC_OPTIONS, "editDerivedData");
     if (!Object.hasOwn(args, "target")) {
       throw new TypeError("editDerivedData requires target.");
     }
@@ -448,72 +469,75 @@ function focusedEditor(op, type, properties) {
   );
 }
 
-export const editComputedData = focusedEditor(
+export const editComputedData = /* @__PURE__ */ focusedEditor(
   "editComputedData", "computed", ["as", "expression"]
 );
-export const editFilteredData = focusedEditor(
-  "editFilteredData", "filter", ["field", "oneOf", "predicate", "range"]
+export const editFilteredData = /* @__PURE__ */ focusedEditor(
+  "editFilteredData", "filter", ["field", "oneOf", "noneOf", "predicate", "range", "nulls"]
 );
-export const editFoldData = focusedEditor(
+export const editFoldData = /* @__PURE__ */ focusedEditor(
   "editFoldData", "fold", ["fields", "as"]
 );
-export const editSummaryData = focusedEditor(
-  "editSummaryData", "summary", ["groupBy", "aggregates", "members", "weight"]
+export const editSummaryData = /* @__PURE__ */ focusedEditor(
+  "editSummaryData", "summary", ["groupBy", "aggregates", "members", "weight", "missing", "empty"]
 );
-export const editBinData = focusedEditor(
+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 = focusedEditor(
+export const editTimeUnitData = /* @__PURE__ */ focusedEditor(
   "editTimeUnitData", "timeUnit", [
     "field", "unit", "as", "temporalUnit", "timeZone", "weekStartsOn",
     "weekRule"
   ]
 );
-export const editWindowData = focusedEditor(
+export const editWindowData = /* @__PURE__ */ focusedEditor(
   "editWindowData", "window", [
     "partitionBy", "sortBy", "operations", "temporalUnit"
   ]
 );
-export const editDensityData = focusedEditor(
+export const editDensityData = /* @__PURE__ */ focusedEditor(
   "editDensityData", "density", [
     "field", "groupBy", "bandwidth", "extent", "steps", "kernel",
-    "normalization", "as", "weight"
+    "normalization", "as", "weight", "missing"
   ]
 );
-export const editStackData = focusedEditor(
+export const editStackData = /* @__PURE__ */ focusedEditor(
   "editStackData", "stack", ["category", "group", "value", "mode", "as"]
 );
-export const editRegressionData = focusedEditor(
+export const editRegressionData = /* @__PURE__ */ focusedEditor(
   "editRegressionData", "regression", [
     "x", "y", "groupBy", "method", "degree", "span", "confidenceMethod",
-    "level", "confidence", "interval"
+    "level", "confidence", "interval", "predict"
   ]
 );
-export const editIntervalData = focusedEditor(
+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 = focusedEditor(
+export const editECDFData = /* @__PURE__ */ focusedEditor(
   "editECDFData", "ecdf", [
     "field", "groupBy", "weight", "missing", "as"
   ]
 );
-export const editNormalizedData = focusedEditor(
+export const editNormalizedData = /* @__PURE__ */ focusedEditor(
   "editNormalizedData", "normalize", [
     "field", "as", "groupBy", "method", "variance", "zeroDenominator",
     "baseline", "sortBy"
   ]
 );
-export const editCompleteData = focusedEditor(
+export const editCompleteData = /* @__PURE__ */ focusedEditor(
   "editCompleteData", "complete", [
     "key", "groupBy", "values", "sequence", "fill", "members"
   ]
 );
-export const editImputedData = focusedEditor(
+export const editImputedData = /* @__PURE__ */ focusedEditor(
   "editImputedData", "impute", [
     "fields", "groupBy", "sortBy", "method", "value", "edges", "maxGap"
   ]
@@ -531,6 +555,7 @@ export const EDIT_DERIVED_DATA_ACTIONS = Object.freeze({
   editDensityData,
   editStackData,
   editRegressionData,
+  editSortedData,
   editIntervalData,
   editECDFData,
   editNormalizedData,

package/src/actions/data/filter.js

@@ -1,6 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
+
 import { withPreviewDatasetValues } from
   "../primitives/semanticAction.js";
 import {
@@ -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",
@@ -50,26 +55,30 @@ function retainedHistogramBoundaries(layer, items) {
   return boundaries.length < 2 ? undefined : boundaries;
 }
 
-export const materializeFilteredData = action(
-  { op: "materializeFilteredData", description: "Materialize one filtered derived dataset." },
+export const materializeFilteredData = /* @__PURE__ */ closedAction(
+  { op: "materializeFilteredData", description: "Materialize one filtered derived dataset." }, MATERIALIZE_OPTIONS,
   function (args = {}) {
-    validateKeys(args, MATERIALIZE_OPTIONS, "materializeFilteredData");
     const { id, source, transform } = requireDerivedDataset(
       this,
       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 });
   }
 );
 
-export const filterData = action(
-  { op: "filterData", description: "Create a named dataset from one field filter." },
+export const filterData = /* @__PURE__ */ closedAction(
+  { op: "filterData", description: "Create a named dataset from one field filter." }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "filterData");
     const id = validateUserId(args.id, "Filtered dataset id");
     const requestedSource = validateUserId(
       args.source ?? this.context.currentData,
@@ -97,13 +106,12 @@ export const filterData = action(
   }
 );
 
-export const materializeMarkFilteredData = action(
+export const materializeMarkFilteredData = /* @__PURE__ */ closedAction(
   {
     op: "materializeMarkFilteredData",
     description: "Materialize member rows retained by one final-item mark selection."
-  },
+  }, MATERIALIZE_OPTIONS,
   function (args = {}) {
-    validateKeys(args, MATERIALIZE_OPTIONS, "materializeMarkFilteredData");
     const { id, dataset, source, transform } = requireDerivedDataset(
       this,
       args.id,
@@ -170,13 +178,12 @@ export const materializeMarkFilteredData = action(
   }
 );
 
-export const materializeEmptyMark = action(
+export const materializeEmptyMark = /* @__PURE__ */ closedAction(
   {
     op: "materializeEmptyMark",
     description: "Clear one active empty-filter mark without changing its domains."
-  },
+  }, EMPTY_MARK_OPTIONS,
   function (args = {}) {
-    validateKeys(args, EMPTY_MARK_OPTIONS, "materializeEmptyMark");
     const id = validateUserId(args.id, "Empty mark id");
     const layer = requireLayer(this, id);
     const owner = this.markConfigs[id]?.markFilter;
@@ -261,13 +268,12 @@ function sameSelector(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
 
-export const removeMarkFilter = action(
+export const removeMarkFilter = /* @__PURE__ */ closedAction(
   {
     op: "removeMarkFilter",
     description: "Remove one active final-item filter and restore its source."
-  },
+  }, REMOVE_MARK_FILTER_OPTIONS,
   function (args = {}) {
-    validateKeys(args, REMOVE_MARK_FILTER_OPTIONS, "removeMarkFilter");
     const target = args.target === undefined
       ? undefined
       : validateUserId(args.target, "Mark filter target id");
@@ -280,13 +286,12 @@ export const removeMarkFilter = action(
   }
 );
 
-export const filterMarks = action(
+export const filterMarks = /* @__PURE__ */ closedAction(
   {
     op: "filterMarks",
     description: "Retain selected final mark items through immutable derived data."
-  },
+  }, MARK_OPTIONS,
   function (args = {}) {
-    validateKeys(args, MARK_OPTIONS, "filterMarks");
     if (args.mode !== undefined && !["replace", "compose"].includes(args.mode)) {
       throw new Error(`Unknown mark filter mode "${args.mode}".`);
     }

package/src/actions/data/fold.js

@@ -6,14 +6,14 @@ import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze(["id", "source", "fields", "as"]);
 
-export const materializeFoldData = derivedMaterializer(
+export const materializeFoldData = /* @__PURE__ */ derivedMaterializer(
   "materializeFoldData",
   "Materialize one immutable wide-to-long dataset.",
   "fold",
   deriveFoldRows
 );
 
-export const createFoldData = derivedCreator(
+export const createFoldData = /* @__PURE__ */ derivedCreator(
   "createFoldData",
   "Create reusable key/value rows from selected wide fields.",
   OPTIONS,

package/src/actions/data/gradientProfile.js

@@ -9,7 +9,7 @@ const OPTIONS = Object.freeze([
   "kernel", "normalization", "center", "as"
 ]);
 
-export const materializeGradientProfileData = derivedMaterializer(
+export const materializeGradientProfileData = /* @__PURE__ */ derivedMaterializer(
   "materializeGradientProfileData",
   "Materialize one categorical density-profile dataset.",
   "gradientProfile",
@@ -24,7 +24,7 @@ export const materializeGradientProfileData = derivedMaterializer(
   }]
 );
 
-export const createGradientProfileData = derivedCreator(
+export const createGradientProfileData = /* @__PURE__ */ derivedCreator(
   "createGradientProfileData",
   "Create one immutable categorical density-profile dataset.",
   OPTIONS,

package/src/actions/data/horizon.js

@@ -26,7 +26,7 @@ function requestedTransform(args) {
   });
 }
 
-export const materializeHorizonData = derivedMaterializer(
+export const materializeHorizonData = /* @__PURE__ */ derivedMaterializer(
   "materializeHorizonData",
   "Materialize one immutable Horizon band dataset.",
   "horizon",
@@ -34,7 +34,7 @@ export const materializeHorizonData = derivedMaterializer(
   result => [{ ...result.transform, resolved: result.resolved }]
 );
 
-export const createHorizonData = derivedCreator(
+export const createHorizonData = /* @__PURE__ */ derivedCreator(
   "createHorizonData",
   "Create one immutable Horizon band dataset.",
   OPTIONS,