@octaviaflow/flow-rules 0.12.0 → 0.13.0

package/dist/catalog/general/aggregate/config.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Aggregate Action — Config Contract
+ *
+ * Fold the upstream records into ONE row — or one row per group — of computed
+ * values. It exists because nothing else could total a column (DEV-422): a
+ * Transform maps one record at a time and cannot see the others, and the only
+ * built-in sum was ForEach's `collect: 'reduce'`, which reduces loop-body
+ * results and is reachable from nowhere an author, or an agent reading
+ * `describe_action_type`, would look.
+ *
+ * Output: `{ data: [ { ...groupKeys, ...metrics } ], _meta }` — the same
+ * `data: row[]` envelope Query, Transform and Variables emit, so the Transform
+ * after it maps `{{totals[].TotalAmount}}` exactly as it maps a Query's rows.
+ *
+ * The Engine's `aggregateExecutor.ts` reads this shape; the two stay in step.
+ */
+/** The functions a metric can apply. `describe_action_type` lists them. */
+export declare const AGGREGATE_FUNCTIONS: readonly ["sum", "count", "avg", "min", "max", "count_distinct", "first", "last"];
+export type AggregateFn = (typeof AGGREGATE_FUNCTIONS)[number];
+/** What each function computes — the panel's help text and the contract's description. */
+export declare const AGGREGATE_FUNCTION_DESCRIPTIONS: Readonly<Record<AggregateFn, string>>;
+export interface AggregateMetric {
+    /** One of `AGGREGATE_FUNCTIONS`. */
+    fn: AggregateFn;
+    /**
+     * The record field it reads — a dot-path such as "Balance" or
+     * "CustomerRef.name". `count` may omit it to count records.
+     */
+    field?: string;
+    /** The key the value lands under on the output row. An identifier, unique within the step. */
+    as: string;
+    /** Round a sum or avg to this many decimal places (0–10). Omit to keep the value as computed. */
+    decimals?: number;
+}
+export interface AggregateConfigType {
+    /**
+     * Which upstream records: a path to an array in the upstream step's output.
+     * Empty means the records the previous step produced (its `data`). Resolved
+     * exactly as ForEach's `arrayPath`.
+     */
+    arrayPath?: string;
+    /**
+     * Record fields (dot-paths) to group by. Empty: one row for all records.
+     * Each key lands on the output row under its last segment
+     * ("CustomerRef.name" → "name").
+     */
+    groupBy?: string[];
+    /** The values to compute. At least one. */
+    metrics: AggregateMetric[];
+    /**
+     * The name later steps use for this result, e.g. `totals` →
+     * `{{totals[].TotalAmount}}`. Defaults to the step's name.
+     */
+    outputAs?: string;
+    /**
+     * The output ROW's schema, written by the panel at save time so the picker
+     * shows the keys before a run. The Backend contributor derives the same
+     * thing from the config with `computeOutputSchema`.
+     */
+    _outputSchema?: {
+        type: 'object';
+        properties: Record<string, unknown>;
+    };
+}
+/** A JSON-schema-like node, as the DataStream and `_outputSchema` carry it. */
+export interface AggregateSchemaNode {
+    type?: string;
+    properties?: Record<string, AggregateSchemaNode>;
+    items?: AggregateSchemaNode;
+    description?: string;
+}
+/**
+ * The output key a group-by field lands under: its last path segment, with a
+ * trailing `[]` removed. "CustomerRef.name" → "name"; "Region" → "Region".
+ * The Engine names the group keys the same way.
+ */
+export declare function groupKeyName(path: string): string;
+export declare const AggregateConfig: {
+    schema: {
+        arrayPath: {
+            type: string;
+            required: boolean;
+            dynamic: boolean;
+            description: string;
+        };
+        groupBy: {
+            type: string;
+            required: boolean;
+            description: string;
+        };
+        metrics: {
+            type: string;
+            required: boolean;
+            description: string;
+        };
+        outputAs: {
+            type: string;
+            required: boolean;
+            description: string;
+        };
+    };
+    defaults: AggregateConfigType;
+    /**
+     * What blocks execution, refused before the run (a 409 on an active flow
+     * over MCP, a warning on a draft): no metrics, an unknown function, a
+     * function with nothing to read, an output key that is not an identifier or
+     * is taken, decimals outside 0–10, an outputAs that is not a single name.
+     */
+    validate(config: Partial<AggregateConfigType>): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * The schema of ONE output row: the group keys (typed from the source record
+     * when `source` is known) and each metric under its `as`. The panel writes
+     * it to `_outputSchema`; the Backend contributor wraps it as `array<row>` at
+     * the step's output path. One implementation, two callers.
+     */
+    computeOutputSchema(config: Partial<AggregateConfigType>, source?: AggregateSchemaNode): {
+        type: "object";
+        properties: Record<string, unknown>;
+    };
+    merge(userConfig: Partial<AggregateConfigType>): AggregateConfigType;
+    /** "sum(Balance), count by name" — the node's auto label. */
+    getLabel(config: Partial<AggregateConfigType>): string;
+};

package/dist/catalog/general/aggregate/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Aggregate Action
+ *
+ * Totals, counts, averages, min/max, distinct counts and first/last over the
+ * upstream records — one output row, or one per group. Sits after the step
+ * that produces the rows and before the step that writes the result (the
+ * "TOTAL row" case: Query → Transform (insert rows) → Aggregate → Transform
+ * (insert one row)). The config contract is `./config.ts` (DEV-422).
+ */
+import { ActionDefinition } from '../../types';
+export declare const aggregateDefinition: ActionDefinition;

package/dist/catalog/index.d.ts

@@ -16,6 +16,7 @@ import { forEachDefinition } from './logic/for-each';
 import { groupDefinition } from './logic/group';
 import { queryDefinition } from './general/query';
 import { transformDefinition } from './general/transform';
+import { aggregateDefinition } from './general/aggregate';
 import { csvActionDefinition } from './storage/csv-action';
 import { jsonActionDefinition } from './storage/json-action';
 import { xmlActionDefinition } from './storage/xml-action';
@@ -54,4 +55,4 @@ export declare const getActionById: (id: string) => ActionDefinition | undefined
  * Get actions by category
  */
 export declare const getActionsByCategory: (category: ActionCategory) => ActionDefinition[];
-export { csvActionDefinition, jsonActionDefinition, xmlActionDefinition, excelActionDefinition, s3ActionDefinition, ftpActionDefinition, googleDriveActionDefinition, dropboxActionDefinition, onedriveActionDefinition, manualTriggerDefinition, scheduleTriggerDefinition, webhookTriggerDefinition, httpRequestDefinition, consoleLogDefinition, delayDefinition, conditionDefinition, forEachDefinition, groupDefinition, queryDefinition, transformDefinition, debugDefinition, errorDefinition, variablesDefinition, graphqlQueryDefinition, emailDefinition, slackMessageDefinition, whatsappSendDefinition, teamsMessageDefinition, googleChatDefinition, webhookCallDefinition, aiAgentDefinition, idpExtractDefinition, };
+export { csvActionDefinition, jsonActionDefinition, xmlActionDefinition, excelActionDefinition, s3ActionDefinition, ftpActionDefinition, googleDriveActionDefinition, dropboxActionDefinition, onedriveActionDefinition, manualTriggerDefinition, scheduleTriggerDefinition, webhookTriggerDefinition, httpRequestDefinition, consoleLogDefinition, delayDefinition, conditionDefinition, forEachDefinition, groupDefinition, queryDefinition, transformDefinition, aggregateDefinition, debugDefinition, errorDefinition, variablesDefinition, graphqlQueryDefinition, emailDefinition, slackMessageDefinition, whatsappSendDefinition, teamsMessageDefinition, googleChatDefinition, webhookCallDefinition, aiAgentDefinition, idpExtractDefinition, };

package/dist/catalog/isOneOf.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Membership test for a readonly string tuple, narrowing the value to the
+ * tuple's union. Shared by the contracts that refuse a value outside a fixed
+ * set (Transform's mode/operation, Aggregate's function) so each names the
+ * allowed values in its message instead of failing at run time.
+ */
+export declare const isOneOf: <T extends string>(set: readonly T[], value: unknown) => value is T;

package/dist/catalog/logic/for-each/recordSchema.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The shape of ONE record at a path in an upstream step's output — what a
+ * step that reads those records sees per row — and the field names it
+ * carries. Pure and framework-free, so a panel that picks a record field
+ * (Aggregate's group-by and metric fields, DEV-422) offers the fields the
+ * Engine's `resolveArrayPath` will actually hand the step.
+ *
+ * Resolution order mirrors the ForEach panel's source resolution: the
+ * upstream node's static schema (`outputSchema`, else the editor's
+ * `config._outputSchema`) walked along the path; then the last run's sample
+ * output; then the static schema as a whole. Only the first upstream node is
+ * consulted — it is the one the step is wired from.
+ */
+import { type UpstreamNodeRef } from './pathOptions';
+export interface RecordSchemaLike {
+    type?: string;
+    properties?: Record<string, any>;
+    items?: any;
+}
+export declare function resolveRecordSchema(upstreamNodes: UpstreamNodeRef[] | undefined, arrayPath: string): RecordSchemaLike | undefined;
+/**
+ * The field names a record at `arrayPath` carries: the resolved schema's
+ * keys, unioned with the ACTUAL keys of the last run's records — live rows
+ * can be sparse or carry system fields a describe-derived schema omits.
+ */
+export declare function detectRecordFields(upstreamNodes: UpstreamNodeRef[] | undefined, arrayPath: string): string[];

package/dist/catalog/types.d.ts

@@ -47,6 +47,7 @@ export declare enum ActionType {
     SpeechToText = "speech_to_text",
     TextToSpeech = "text_to_speech",
     Transform = "transform",
+    Aggregate = "aggregate",
     FileOperation = "file_operation",
     FileAction = "file_action",
     CsvAction = "csv_action",

package/dist/index.cjs

@@ -39,9 +39,12 @@ var __export = (target, all) => {
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
+  AGGREGATE_FUNCTIONS: () => AGGREGATE_FUNCTIONS,
+  AGGREGATE_FUNCTION_DESCRIPTIONS: () => AGGREGATE_FUNCTION_DESCRIPTIONS,
   ActionCategory: () => ActionCategory,
   ActionStatus: () => ActionStatus,
   ActionType: () => ActionType,
+  AggregateConfig: () => AggregateConfig,
   AggregateFunction: () => AggregateFunction,
   AiAgentConfig: () => AiAgentConfig,
   CONDITION_OPERATORS: () => CONDITION_OPERATORS,
@@ -113,6 +116,7 @@ __export(exports_src, {
   contractFor: () => contractFor,
   contractVocabularyDrift: () => contractVocabularyDrift,
   declaredKeys: () => declaredKeys,
+  detectRecordFields: () => detectRecordFields,
   emailDefinition: () => emailDefinition,
   fileEditErrors: () => fileEditErrors,
   fileFormatErrors: () => fileFormatErrors,
@@ -130,6 +134,7 @@ __export(exports_src, {
   getNodeConfigStatus: () => getNodeConfigStatus,
   getNodeValidationStatus: () => getNodeValidationStatus,
   getStorageProvider: () => getStorageProvider,
+  groupKeyName: () => groupKeyName,
   inferSchemaFromSample: () => inferSchemaFromSample,
   isEditorPrivateKey: () => isEditorPrivateKey,
   isEventCapableConnector: () => isEventCapableConnector,
@@ -138,6 +143,7 @@ __export(exports_src, {
   mappingTransformFunctionName: () => mappingTransformFunctionName,
   migrateDelayConfig: () => migrateDelayConfig,
   queryDefinition: () => queryDefinition,
+  resolveRecordSchema: () => resolveRecordSchema,
   selectsWithoutValues: () => selectsWithoutValues,
   storageConfigKeys: () => storageConfigKeys,
   storageOperations: () => storageOperations,
@@ -202,6 +208,7 @@ var ActionType;
   ActionType["SpeechToText"] = "speech_to_text";
   ActionType["TextToSpeech"] = "text_to_speech";
   ActionType["Transform"] = "transform";
+  ActionType["Aggregate"] = "aggregate";
   ActionType["FileOperation"] = "file_operation";
   ActionType["FileAction"] = "file_action";
   ActionType["CsvAction"] = "csv_action";
@@ -1744,6 +1751,46 @@ var transformDefinition = {
   testable: true
 };
 
+// src/catalog/general/aggregate/index.ts
+var aggregateDefinition = {
+  id: "aggregate",
+  name: "Aggregate",
+  description: "Total, count or average the upstream records into one row — or one row per group — of computed values " + "(sum, count, avg, min, max, count_distinct, first, last). Put it after the step that produces the rows and " + "before the step that writes the result, for example a TOTAL row under the rows a Transform just wrote.",
+  category: "transform" /* Transform */,
+  type: "aggregate" /* Aggregate */,
+  tags: ["aggregate", "sum", "total", "count", "average", "min", "max", "group by", "rollup", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Sigma",
+  color: "#0043ce",
+  inputSchema: { fields: [] },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "data",
+        type: "array" /* Array */,
+        description: "One row per group (a single row when there is no group-by): the group keys, then each metric under its `as` key"
+      },
+      {
+        key: "_meta",
+        type: "object" /* Object */,
+        description: "rowsIn, groups, and ignored — values skipped for a numeric metric because they were not numbers"
+      }
+    ],
+    sampleOutput: {
+      data: [{ TotalAmount: 12850.4, Invoices: 35 }],
+      _meta: { rowsIn: 35, groups: 1, ignored: 0 }
+    },
+    dynamic: true
+  },
+  version: "1.0.0",
+  createdAt: "2026-10-08T00:00:00Z",
+  updatedAt: "2026-10-08T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
 // src/catalog/storage/csv-action/index.ts
 var csvActionDefinition = {
   id: "csv_action",
@@ -2803,7 +2850,8 @@ var actionsRegistry = {
     console_log: consoleLogDefinition,
     delay: delayDefinition,
     query: queryDefinition,
-    transform: transformDefinition
+    transform: transformDefinition,
+    aggregate: aggregateDefinition
   },
   ["logic" /* Logic */]: {
     condition: conditionDefinition,
@@ -3781,6 +3829,9 @@ var EmailConfig = {
     }
   }
 };
+// src/catalog/isOneOf.ts
+var isOneOf = (set, value) => typeof value === "string" && set.includes(value);
+
 // src/catalog/general/transform/config.ts
 var TRANSFORM_MODES = ["visual", "expression"];
 var TRANSFORM_OPERATIONS = [
@@ -3790,7 +3841,6 @@ var TRANSFORM_OPERATIONS = [
   { id: "delete", label: "Delete" }
 ];
 var TRANSFORM_OPERATION_IDS = TRANSFORM_OPERATIONS.map((o) => o.id);
-var isOneOf = (set, value) => typeof value === "string" && set.includes(value);
 var DATABASE_CONNECTOR_IDS = new Set(["mongodb", "postgresql", "mysql", "sqlite", "google_sheets"]);
 var TransformConfig = {
   defaults: {
@@ -3892,6 +3942,313 @@ var TransformConfig = {
     return `map_${Date.now()}_${randomSuffix(5)}`;
   }
 };
+// src/catalog/general/aggregate/config.ts
+var AGGREGATE_FUNCTIONS = [
+  "sum",
+  "count",
+  "avg",
+  "min",
+  "max",
+  "count_distinct",
+  "first",
+  "last"
+];
+var AGGREGATE_FUNCTION_DESCRIPTIONS = {
+  sum: "add up the numeric values of a field",
+  count: "count the records (with a field: the records where it is not blank)",
+  avg: "the mean of the numeric values of a field",
+  min: "the smallest value of a field",
+  max: "the largest value of a field",
+  count_distinct: "how many different values a field has",
+  first: "the field's value on the first record",
+  last: "the field's value on the last record"
+};
+var RESERVED_KEYS2 = new Set(["_meta", "_lineage", "_redacted", "_error"]);
+var KEY_PATTERN2 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var NUMBER_VALUED = new Set(["sum", "avg", "count", "count_distinct"]);
+function groupKeyName(path) {
+  const trimmed = String(path ?? "").trim().replace(/\[\]$/, "");
+  const segments = trimmed.split(".").filter(Boolean);
+  return segments.length > 0 ? segments[segments.length - 1] : trimmed;
+}
+function schemaAt(schema, path) {
+  let cur = schema;
+  for (const part of path.replace(/\[\]$/, "").split(".").filter(Boolean)) {
+    if (!cur)
+      return;
+    if (cur.type === "array" && cur.items)
+      cur = cur.items;
+    const next = cur.properties?.[part];
+    if (!next)
+      return;
+    cur = next;
+  }
+  return cur;
+}
+function leafOf(node, fallback) {
+  const t = node?.type;
+  if (t === "number" || t === "integer" || t === "string" || t === "boolean" || t === "date")
+    return { type: t };
+  return { type: fallback };
+}
+function metricSchema(metric, source) {
+  const what = metric.field ? `${metric.fn} of ${metric.field}` : metric.fn;
+  if (NUMBER_VALUED.has(metric.fn))
+    return { type: "number", description: what };
+  return { ...leafOf(metric.field ? schemaAt(source, metric.field) : undefined, "string"), description: what };
+}
+var FUNCTION_LIST = AGGREGATE_FUNCTIONS.join(", ");
+var AggregateConfig = {
+  schema: {
+    arrayPath: {
+      type: "select",
+      required: false,
+      dynamic: true,
+      description: "Which upstream records to aggregate: a path to an array in the upstream step's output. " + "Leave empty for the records the previous step produced (its data). The values come from that step's data, not from the catalog."
+    },
+    groupBy: {
+      type: "array",
+      required: false,
+      description: 'Record fields (dot-paths) to group by, e.g. ["CustomerRef.name"]. Empty: one row for all records. ' + 'Each key lands on the output row under its last segment ("name").'
+    },
+    metrics: {
+      type: "array",
+      required: true,
+      description: 'What to compute, at least one: [{ "fn", "field", "as", "decimals"? }]. ' + `fn is one of ${FUNCTION_LIST} (` + AGGREGATE_FUNCTIONS.map((fn) => `${fn}: ${AGGREGATE_FUNCTION_DESCRIPTIONS[fn]}`).join("; ") + "). field is the record key it reads (a dot-path; count may omit it to count records). " + "as is the output key. decimals rounds a sum or avg. " + 'Example: [{ "fn": "sum", "field": "Balance", "as": "TotalAmount", "decimals": 2 }, { "fn": "count", "as": "Invoices" }]'
+    },
+    outputAs: {
+      type: "string",
+      required: false,
+      description: "The name later steps use for this result, e.g. totals → {{totals[].TotalAmount}}. Defaults to the step name."
+    }
+  },
+  defaults: {
+    arrayPath: "",
+    groupBy: [],
+    metrics: [],
+    outputAs: ""
+  },
+  validate(config) {
+    const errors = [];
+    const metrics = Array.isArray(config.metrics) ? config.metrics : [];
+    if (metrics.length === 0) {
+      errors.push('Add at least one metric — what to compute, e.g. { "fn": "sum", "field": "Balance", "as": "TotalAmount" }.');
+    }
+    const groupKeys = [];
+    const groupBy = config.groupBy;
+    if (groupBy !== undefined && groupBy !== null) {
+      if (!Array.isArray(groupBy)) {
+        errors.push('groupBy must be a list of record fields (dot-paths), e.g. ["CustomerRef.name"].');
+      } else {
+        for (const g of groupBy) {
+          if (typeof g !== "string" || g.trim() === "") {
+            errors.push("groupBy has an empty entry — each one is a record field (dot-path).");
+            continue;
+          }
+          groupKeys.push(groupKeyName(g));
+        }
+      }
+    }
+    const seen = new Set;
+    for (const key of groupKeys) {
+      if (seen.has(key)) {
+        errors.push(`Two group-by fields both land under "${key}" — group by fields whose last segment differs.`);
+      }
+      seen.add(key);
+    }
+    metrics.forEach((m, i) => {
+      const where = m && typeof m === "object" && typeof m.as === "string" && m.as ? `"${m.as}"` : `metric ${i + 1}`;
+      if (!m || typeof m !== "object") {
+        errors.push(`${where}: a metric is an object { "fn", "field", "as" }.`);
+        return;
+      }
+      const fn = m.fn;
+      const fnValid = isOneOf(AGGREGATE_FUNCTIONS, fn);
+      if (fn === undefined || fn === null || fn === "") {
+        errors.push(`${where}: fn is required — one of ${FUNCTION_LIST}.`);
+      } else if (!fnValid) {
+        errors.push(`${where}: fn must be one of: ${FUNCTION_LIST} (got "${String(fn)}").`);
+      }
+      const field = m.field;
+      if (field !== undefined && field !== null && typeof field !== "string") {
+        errors.push(`${where}: field must be a string — a dot-path on the record, e.g. "Balance".`);
+      } else if (fnValid && fn !== "count" && (typeof field !== "string" || field.trim() === "")) {
+        errors.push(`${where}: ${fn} needs a field — the record key it reads, e.g. "Balance".`);
+      }
+      const as = m.as;
+      if (typeof as !== "string" || as === "") {
+        errors.push(`${where}: as is required — the output key the value lands under, e.g. "TotalAmount".`);
+      } else if (RESERVED_KEYS2.has(as)) {
+        errors.push(`"${as}" is reserved — pick another output key.`);
+      } else if (!KEY_PATTERN2.test(as)) {
+        errors.push(`"${as}" is not a valid output key (letters, digits, underscore; must not start with a digit).`);
+      } else if (seen.has(as)) {
+        errors.push(`Duplicate output key "${as}" — every metric and group-by key lands under its own name.`);
+      } else {
+        seen.add(as);
+      }
+      const decimals = m.decimals;
+      if (decimals !== undefined && decimals !== null) {
+        if (typeof decimals !== "number" || !Number.isInteger(decimals) || decimals < 0 || decimals > 10) {
+          errors.push(`${where}: decimals must be a whole number from 0 to 10.`);
+        }
+      }
+    });
+    const outputAs = config.outputAs;
+    if (outputAs !== undefined && outputAs !== null && outputAs !== "") {
+      if (typeof outputAs !== "string" || !KEY_PATTERN2.test(outputAs)) {
+        errors.push('outputAs must be a single name (letters, digits, underscore), e.g. "totals" — later steps read {{totals[].<key>}}.');
+      }
+    }
+    const arrayPath = config.arrayPath;
+    if (arrayPath !== undefined && arrayPath !== null && typeof arrayPath !== "string") {
+      errors.push("arrayPath must be a string — a path to an array in the upstream output, or empty for its records.");
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  computeOutputSchema(config, source) {
+    const properties = {};
+    for (const g of Array.isArray(config.groupBy) ? config.groupBy : []) {
+      if (typeof g !== "string" || g.trim() === "")
+        continue;
+      properties[groupKeyName(g)] = { ...leafOf(schemaAt(source, g), "string"), description: `group: ${g}` };
+    }
+    for (const m of Array.isArray(config.metrics) ? config.metrics : []) {
+      if (!m || typeof m !== "object" || typeof m.as !== "string" || !m.as || !isOneOf(AGGREGATE_FUNCTIONS, m.fn))
+        continue;
+      properties[m.as] = metricSchema(m, source);
+    }
+    return { type: "object", properties };
+  },
+  merge(userConfig) {
+    return { ...AggregateConfig.defaults, ...userConfig };
+  },
+  getLabel(config) {
+    const metrics = Array.isArray(config.metrics) ? config.metrics : [];
+    const parts = metrics.filter((m) => m && typeof m === "object" && m.fn).map((m) => m.field ? `${m.fn}(${m.field})` : String(m.fn));
+    const by = Array.isArray(config.groupBy) && config.groupBy.length > 0 ? ` by ${config.groupBy.map(groupKeyName).join(", ")}` : "";
+    return parts.length > 0 ? `${parts.join(", ")}${by}` : "Aggregate";
+  }
+};
+// src/catalog/logic/for-each/recordSchema.ts
+function resolveSchemaPath(root, path) {
+  if (!root)
+    return;
+  const parts = path.split(".").filter(Boolean);
+  let cur = root;
+  for (const part of parts) {
+    if (cur?.type === "object" && cur.properties && part in cur.properties) {
+      cur = cur.properties[part];
+      continue;
+    }
+    if (cur?.type === "array" && cur.items?.properties && part in cur.items.properties) {
+      cur = cur.items.properties[part];
+      continue;
+    }
+    return;
+  }
+  if (cur?.type === "array" && cur.items)
+    return cur.items;
+  if (cur?.type === "object" && cur.properties)
+    return cur;
+  return;
+}
+function resolveSamplePath(sample, path) {
+  const parts = path.split(".").filter(Boolean);
+  let cur = sample;
+  for (const part of parts) {
+    if (cur === null || cur === undefined)
+      return;
+    if (Array.isArray(cur)) {
+      if (cur.length === 0 || typeof cur[0] !== "object" || cur[0] === null)
+        return;
+      cur = cur[0][part];
+      continue;
+    }
+    if (typeof cur === "object") {
+      cur = cur[part];
+      continue;
+    }
+    return;
+  }
+  return cur;
+}
+function sampleRecords(node) {
+  const output = node?.executionData?.output;
+  if (!output)
+    return null;
+  if (Array.isArray(output))
+    return output;
+  const data = output.data;
+  return Array.isArray(data) ? data : null;
+}
+var isRootPath = (path) => path === "" || path === "data";
+function resolveRecordSchema(upstreamNodes, arrayPath) {
+  const node = upstreamNodes?.[0];
+  if (!node)
+    return;
+  const path = (arrayPath || "").trim();
+  const isRoot = isRootPath(path);
+  const schema = node.outputSchema || node.config?._outputSchema;
+  if (schema?.properties) {
+    if (isRoot) {
+      const hasDeepFields = Object.values(schema.properties).some((f) => f?.properties || f?.items);
+      if (hasDeepFields)
+        return schema;
+    } else {
+      const resolved = resolveSchemaPath(schema, path);
+      if (resolved)
+        return resolved;
+    }
+  }
+  const records = sampleRecords(node);
+  if (records && records.length > 0 && typeof records[0] === "object" && records[0] !== null) {
+    const sample = records[0];
+    if (isRoot)
+      return inferSchemaFromSample(sample);
+    const resolved = resolveSamplePath(sample, path);
+    if (Array.isArray(resolved) && resolved.length > 0 && typeof resolved[0] === "object" && resolved[0] !== null) {
+      return inferSchemaFromSample(resolved[0]);
+    }
+    if (resolved && typeof resolved === "object" && !Array.isArray(resolved)) {
+      return inferSchemaFromSample(resolved);
+    }
+    if (!path.includes("."))
+      return inferSchemaFromSample(sample);
+  }
+  return schema?.properties ? schema : undefined;
+}
+function detectRecordFields(upstreamNodes, arrayPath) {
+  const set = new Set;
+  const props = resolveRecordSchema(upstreamNodes, arrayPath)?.properties;
+  if (props && typeof props === "object")
+    for (const k of Object.keys(props))
+      set.add(k);
+  const records = sampleRecords(upstreamNodes?.[0]);
+  if (records) {
+    const path = (arrayPath || "").trim();
+    const addKeys = (v) => {
+      if (v && typeof v === "object" && !Array.isArray(v))
+        for (const k of Object.keys(v))
+          set.add(k);
+    };
+    for (const r of records.slice(0, 25)) {
+      if (isRootPath(path)) {
+        addKeys(r);
+        continue;
+      }
+      const at = resolveSamplePath(r, path);
+      if (Array.isArray(at))
+        for (const item of at.slice(0, 25))
+          addKeys(item);
+      else if (at && typeof at === "object")
+        addKeys(at);
+      else if (!path.includes("."))
+        addKeys(r);
+    }
+  }
+  return Array.from(set);
+}
 // src/catalog/storage/storageCapabilities.ts
 var contentTypeField = {
   key: "contentType",
@@ -5619,6 +5976,7 @@ var CONFIG_CONTRACTS = {
     }
   },
   transform: { schema: TransformConfig.schema, validate: asValidator(TransformConfig.validate) },
+  aggregate: { schema: AggregateConfig.schema, validate: asValidator(AggregateConfig.validate) },
   condition: { schema: ConditionConfig.schema, validate: asValidator(ConditionConfig.validate) },
   for_each: { schema: ForEachConfig.schema, validate: asValidator(ForEachConfig.validate) },
   file_operation: { schema: FileOperationConfig.schema, validate: asValidator(FileOperationConfig.validate) },

package/dist/index.d.ts

@@ -37,6 +37,8 @@ export { queryDefinition, } from "./catalog/general/query/index";
 export { isQueryableConnector, } from "./catalog/general/query/config";
 export { AggregateFunction, type BuildQueryConfig, type ColumnSchema, type ConnectorSchema, JoinType, LogicalOperator, type QueryExecutionResult, type QueryField, type QueryFilter, type QueryFilterGroup, type QueryJoin, type QuerySort, SortDirection, type VisualQueryConfig, } from "./catalog/general/query/types";
 export { DATABASE_CONNECTOR_IDS, type FieldMapping, TRANSFORM_MODES, TRANSFORM_OPERATIONS, TransformConfig, type TransformConfigType, type TransformOperation, } from "./catalog/general/transform/config";
+export { AGGREGATE_FUNCTIONS, AGGREGATE_FUNCTION_DESCRIPTIONS, AggregateConfig, type AggregateConfigType, type AggregateFn, type AggregateMetric, type AggregateSchemaNode, groupKeyName, } from "./catalog/general/aggregate/config";
+export { detectRecordFields, resolveRecordSchema, type RecordSchemaLike, } from "./catalog/logic/for-each/recordSchema";
 export { STORAGE_CONNECTOR_IDS, type StorageExtraField, type StoragePathField, getStorageProvider, storageConfigKeys, } from "./catalog/storage/storageCapabilities";
 export { ManualTriggerConfig } from "./catalog/triggers/manual-trigger/index";
 export { AiAgentConfig, type AiAgentConfigType, type AiAgentOverrides } from "./catalog/ai/ai-agent/config";

package/dist/index.js

@@ -45,6 +45,7 @@ var ActionType;
   ActionType["SpeechToText"] = "speech_to_text";
   ActionType["TextToSpeech"] = "text_to_speech";
   ActionType["Transform"] = "transform";
+  ActionType["Aggregate"] = "aggregate";
   ActionType["FileOperation"] = "file_operation";
   ActionType["FileAction"] = "file_action";
   ActionType["CsvAction"] = "csv_action";
@@ -1587,6 +1588,46 @@ var transformDefinition = {
   testable: true
 };
 
+// src/catalog/general/aggregate/index.ts
+var aggregateDefinition = {
+  id: "aggregate",
+  name: "Aggregate",
+  description: "Total, count or average the upstream records into one row — or one row per group — of computed values " + "(sum, count, avg, min, max, count_distinct, first, last). Put it after the step that produces the rows and " + "before the step that writes the result, for example a TOTAL row under the rows a Transform just wrote.",
+  category: "transform" /* Transform */,
+  type: "aggregate" /* Aggregate */,
+  tags: ["aggregate", "sum", "total", "count", "average", "min", "max", "group by", "rollup", "built-in"],
+  status: "stable" /* Stable */,
+  icon: "Sigma",
+  color: "#0043ce",
+  inputSchema: { fields: [] },
+  outputSchema: {
+    type: "object",
+    properties: [
+      {
+        key: "data",
+        type: "array" /* Array */,
+        description: "One row per group (a single row when there is no group-by): the group keys, then each metric under its `as` key"
+      },
+      {
+        key: "_meta",
+        type: "object" /* Object */,
+        description: "rowsIn, groups, and ignored — values skipped for a numeric metric because they were not numbers"
+      }
+    ],
+    sampleOutput: {
+      data: [{ TotalAmount: 12850.4, Invoices: 35 }],
+      _meta: { rowsIn: 35, groups: 1, ignored: 0 }
+    },
+    dynamic: true
+  },
+  version: "1.0.0",
+  createdAt: "2026-10-08T00:00:00Z",
+  updatedAt: "2026-10-08T00:00:00Z",
+  createdBy: "system",
+  isOfficial: true,
+  testable: false
+};
+
 // src/catalog/storage/csv-action/index.ts
 var csvActionDefinition = {
   id: "csv_action",
@@ -2646,7 +2687,8 @@ var actionsRegistry = {
     console_log: consoleLogDefinition,
     delay: delayDefinition,
     query: queryDefinition,
-    transform: transformDefinition
+    transform: transformDefinition,
+    aggregate: aggregateDefinition
   },
   ["logic" /* Logic */]: {
     condition: conditionDefinition,
@@ -3624,6 +3666,9 @@ var EmailConfig = {
     }
   }
 };
+// src/catalog/isOneOf.ts
+var isOneOf = (set, value) => typeof value === "string" && set.includes(value);
+
 // src/catalog/general/transform/config.ts
 var TRANSFORM_MODES = ["visual", "expression"];
 var TRANSFORM_OPERATIONS = [
@@ -3633,7 +3678,6 @@ var TRANSFORM_OPERATIONS = [
   { id: "delete", label: "Delete" }
 ];
 var TRANSFORM_OPERATION_IDS = TRANSFORM_OPERATIONS.map((o) => o.id);
-var isOneOf = (set, value) => typeof value === "string" && set.includes(value);
 var DATABASE_CONNECTOR_IDS = new Set(["mongodb", "postgresql", "mysql", "sqlite", "google_sheets"]);
 var TransformConfig = {
   defaults: {
@@ -3735,6 +3779,313 @@ var TransformConfig = {
     return `map_${Date.now()}_${randomSuffix(5)}`;
   }
 };
+// src/catalog/general/aggregate/config.ts
+var AGGREGATE_FUNCTIONS = [
+  "sum",
+  "count",
+  "avg",
+  "min",
+  "max",
+  "count_distinct",
+  "first",
+  "last"
+];
+var AGGREGATE_FUNCTION_DESCRIPTIONS = {
+  sum: "add up the numeric values of a field",
+  count: "count the records (with a field: the records where it is not blank)",
+  avg: "the mean of the numeric values of a field",
+  min: "the smallest value of a field",
+  max: "the largest value of a field",
+  count_distinct: "how many different values a field has",
+  first: "the field's value on the first record",
+  last: "the field's value on the last record"
+};
+var RESERVED_KEYS2 = new Set(["_meta", "_lineage", "_redacted", "_error"]);
+var KEY_PATTERN2 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var NUMBER_VALUED = new Set(["sum", "avg", "count", "count_distinct"]);
+function groupKeyName(path) {
+  const trimmed = String(path ?? "").trim().replace(/\[\]$/, "");
+  const segments = trimmed.split(".").filter(Boolean);
+  return segments.length > 0 ? segments[segments.length - 1] : trimmed;
+}
+function schemaAt(schema, path) {
+  let cur = schema;
+  for (const part of path.replace(/\[\]$/, "").split(".").filter(Boolean)) {
+    if (!cur)
+      return;
+    if (cur.type === "array" && cur.items)
+      cur = cur.items;
+    const next = cur.properties?.[part];
+    if (!next)
+      return;
+    cur = next;
+  }
+  return cur;
+}
+function leafOf(node, fallback) {
+  const t = node?.type;
+  if (t === "number" || t === "integer" || t === "string" || t === "boolean" || t === "date")
+    return { type: t };
+  return { type: fallback };
+}
+function metricSchema(metric, source) {
+  const what = metric.field ? `${metric.fn} of ${metric.field}` : metric.fn;
+  if (NUMBER_VALUED.has(metric.fn))
+    return { type: "number", description: what };
+  return { ...leafOf(metric.field ? schemaAt(source, metric.field) : undefined, "string"), description: what };
+}
+var FUNCTION_LIST = AGGREGATE_FUNCTIONS.join(", ");
+var AggregateConfig = {
+  schema: {
+    arrayPath: {
+      type: "select",
+      required: false,
+      dynamic: true,
+      description: "Which upstream records to aggregate: a path to an array in the upstream step's output. " + "Leave empty for the records the previous step produced (its data). The values come from that step's data, not from the catalog."
+    },
+    groupBy: {
+      type: "array",
+      required: false,
+      description: 'Record fields (dot-paths) to group by, e.g. ["CustomerRef.name"]. Empty: one row for all records. ' + 'Each key lands on the output row under its last segment ("name").'
+    },
+    metrics: {
+      type: "array",
+      required: true,
+      description: 'What to compute, at least one: [{ "fn", "field", "as", "decimals"? }]. ' + `fn is one of ${FUNCTION_LIST} (` + AGGREGATE_FUNCTIONS.map((fn) => `${fn}: ${AGGREGATE_FUNCTION_DESCRIPTIONS[fn]}`).join("; ") + "). field is the record key it reads (a dot-path; count may omit it to count records). " + "as is the output key. decimals rounds a sum or avg. " + 'Example: [{ "fn": "sum", "field": "Balance", "as": "TotalAmount", "decimals": 2 }, { "fn": "count", "as": "Invoices" }]'
+    },
+    outputAs: {
+      type: "string",
+      required: false,
+      description: "The name later steps use for this result, e.g. totals → {{totals[].TotalAmount}}. Defaults to the step name."
+    }
+  },
+  defaults: {
+    arrayPath: "",
+    groupBy: [],
+    metrics: [],
+    outputAs: ""
+  },
+  validate(config) {
+    const errors = [];
+    const metrics = Array.isArray(config.metrics) ? config.metrics : [];
+    if (metrics.length === 0) {
+      errors.push('Add at least one metric — what to compute, e.g. { "fn": "sum", "field": "Balance", "as": "TotalAmount" }.');
+    }
+    const groupKeys = [];
+    const groupBy = config.groupBy;
+    if (groupBy !== undefined && groupBy !== null) {
+      if (!Array.isArray(groupBy)) {
+        errors.push('groupBy must be a list of record fields (dot-paths), e.g. ["CustomerRef.name"].');
+      } else {
+        for (const g of groupBy) {
+          if (typeof g !== "string" || g.trim() === "") {
+            errors.push("groupBy has an empty entry — each one is a record field (dot-path).");
+            continue;
+          }
+          groupKeys.push(groupKeyName(g));
+        }
+      }
+    }
+    const seen = new Set;
+    for (const key of groupKeys) {
+      if (seen.has(key)) {
+        errors.push(`Two group-by fields both land under "${key}" — group by fields whose last segment differs.`);
+      }
+      seen.add(key);
+    }
+    metrics.forEach((m, i) => {
+      const where = m && typeof m === "object" && typeof m.as === "string" && m.as ? `"${m.as}"` : `metric ${i + 1}`;
+      if (!m || typeof m !== "object") {
+        errors.push(`${where}: a metric is an object { "fn", "field", "as" }.`);
+        return;
+      }
+      const fn = m.fn;
+      const fnValid = isOneOf(AGGREGATE_FUNCTIONS, fn);
+      if (fn === undefined || fn === null || fn === "") {
+        errors.push(`${where}: fn is required — one of ${FUNCTION_LIST}.`);
+      } else if (!fnValid) {
+        errors.push(`${where}: fn must be one of: ${FUNCTION_LIST} (got "${String(fn)}").`);
+      }
+      const field = m.field;
+      if (field !== undefined && field !== null && typeof field !== "string") {
+        errors.push(`${where}: field must be a string — a dot-path on the record, e.g. "Balance".`);
+      } else if (fnValid && fn !== "count" && (typeof field !== "string" || field.trim() === "")) {
+        errors.push(`${where}: ${fn} needs a field — the record key it reads, e.g. "Balance".`);
+      }
+      const as = m.as;
+      if (typeof as !== "string" || as === "") {
+        errors.push(`${where}: as is required — the output key the value lands under, e.g. "TotalAmount".`);
+      } else if (RESERVED_KEYS2.has(as)) {
+        errors.push(`"${as}" is reserved — pick another output key.`);
+      } else if (!KEY_PATTERN2.test(as)) {
+        errors.push(`"${as}" is not a valid output key (letters, digits, underscore; must not start with a digit).`);
+      } else if (seen.has(as)) {
+        errors.push(`Duplicate output key "${as}" — every metric and group-by key lands under its own name.`);
+      } else {
+        seen.add(as);
+      }
+      const decimals = m.decimals;
+      if (decimals !== undefined && decimals !== null) {
+        if (typeof decimals !== "number" || !Number.isInteger(decimals) || decimals < 0 || decimals > 10) {
+          errors.push(`${where}: decimals must be a whole number from 0 to 10.`);
+        }
+      }
+    });
+    const outputAs = config.outputAs;
+    if (outputAs !== undefined && outputAs !== null && outputAs !== "") {
+      if (typeof outputAs !== "string" || !KEY_PATTERN2.test(outputAs)) {
+        errors.push('outputAs must be a single name (letters, digits, underscore), e.g. "totals" — later steps read {{totals[].<key>}}.');
+      }
+    }
+    const arrayPath = config.arrayPath;
+    if (arrayPath !== undefined && arrayPath !== null && typeof arrayPath !== "string") {
+      errors.push("arrayPath must be a string — a path to an array in the upstream output, or empty for its records.");
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  computeOutputSchema(config, source) {
+    const properties = {};
+    for (const g of Array.isArray(config.groupBy) ? config.groupBy : []) {
+      if (typeof g !== "string" || g.trim() === "")
+        continue;
+      properties[groupKeyName(g)] = { ...leafOf(schemaAt(source, g), "string"), description: `group: ${g}` };
+    }
+    for (const m of Array.isArray(config.metrics) ? config.metrics : []) {
+      if (!m || typeof m !== "object" || typeof m.as !== "string" || !m.as || !isOneOf(AGGREGATE_FUNCTIONS, m.fn))
+        continue;
+      properties[m.as] = metricSchema(m, source);
+    }
+    return { type: "object", properties };
+  },
+  merge(userConfig) {
+    return { ...AggregateConfig.defaults, ...userConfig };
+  },
+  getLabel(config) {
+    const metrics = Array.isArray(config.metrics) ? config.metrics : [];
+    const parts = metrics.filter((m) => m && typeof m === "object" && m.fn).map((m) => m.field ? `${m.fn}(${m.field})` : String(m.fn));
+    const by = Array.isArray(config.groupBy) && config.groupBy.length > 0 ? ` by ${config.groupBy.map(groupKeyName).join(", ")}` : "";
+    return parts.length > 0 ? `${parts.join(", ")}${by}` : "Aggregate";
+  }
+};
+// src/catalog/logic/for-each/recordSchema.ts
+function resolveSchemaPath(root, path) {
+  if (!root)
+    return;
+  const parts = path.split(".").filter(Boolean);
+  let cur = root;
+  for (const part of parts) {
+    if (cur?.type === "object" && cur.properties && part in cur.properties) {
+      cur = cur.properties[part];
+      continue;
+    }
+    if (cur?.type === "array" && cur.items?.properties && part in cur.items.properties) {
+      cur = cur.items.properties[part];
+      continue;
+    }
+    return;
+  }
+  if (cur?.type === "array" && cur.items)
+    return cur.items;
+  if (cur?.type === "object" && cur.properties)
+    return cur;
+  return;
+}
+function resolveSamplePath(sample, path) {
+  const parts = path.split(".").filter(Boolean);
+  let cur = sample;
+  for (const part of parts) {
+    if (cur === null || cur === undefined)
+      return;
+    if (Array.isArray(cur)) {
+      if (cur.length === 0 || typeof cur[0] !== "object" || cur[0] === null)
+        return;
+      cur = cur[0][part];
+      continue;
+    }
+    if (typeof cur === "object") {
+      cur = cur[part];
+      continue;
+    }
+    return;
+  }
+  return cur;
+}
+function sampleRecords(node) {
+  const output = node?.executionData?.output;
+  if (!output)
+    return null;
+  if (Array.isArray(output))
+    return output;
+  const data = output.data;
+  return Array.isArray(data) ? data : null;
+}
+var isRootPath = (path) => path === "" || path === "data";
+function resolveRecordSchema(upstreamNodes, arrayPath) {
+  const node = upstreamNodes?.[0];
+  if (!node)
+    return;
+  const path = (arrayPath || "").trim();
+  const isRoot = isRootPath(path);
+  const schema = node.outputSchema || node.config?._outputSchema;
+  if (schema?.properties) {
+    if (isRoot) {
+      const hasDeepFields = Object.values(schema.properties).some((f) => f?.properties || f?.items);
+      if (hasDeepFields)
+        return schema;
+    } else {
+      const resolved = resolveSchemaPath(schema, path);
+      if (resolved)
+        return resolved;
+    }
+  }
+  const records = sampleRecords(node);
+  if (records && records.length > 0 && typeof records[0] === "object" && records[0] !== null) {
+    const sample = records[0];
+    if (isRoot)
+      return inferSchemaFromSample(sample);
+    const resolved = resolveSamplePath(sample, path);
+    if (Array.isArray(resolved) && resolved.length > 0 && typeof resolved[0] === "object" && resolved[0] !== null) {
+      return inferSchemaFromSample(resolved[0]);
+    }
+    if (resolved && typeof resolved === "object" && !Array.isArray(resolved)) {
+      return inferSchemaFromSample(resolved);
+    }
+    if (!path.includes("."))
+      return inferSchemaFromSample(sample);
+  }
+  return schema?.properties ? schema : undefined;
+}
+function detectRecordFields(upstreamNodes, arrayPath) {
+  const set = new Set;
+  const props = resolveRecordSchema(upstreamNodes, arrayPath)?.properties;
+  if (props && typeof props === "object")
+    for (const k of Object.keys(props))
+      set.add(k);
+  const records = sampleRecords(upstreamNodes?.[0]);
+  if (records) {
+    const path = (arrayPath || "").trim();
+    const addKeys = (v) => {
+      if (v && typeof v === "object" && !Array.isArray(v))
+        for (const k of Object.keys(v))
+          set.add(k);
+    };
+    for (const r of records.slice(0, 25)) {
+      if (isRootPath(path)) {
+        addKeys(r);
+        continue;
+      }
+      const at = resolveSamplePath(r, path);
+      if (Array.isArray(at))
+        for (const item of at.slice(0, 25))
+          addKeys(item);
+      else if (at && typeof at === "object")
+        addKeys(at);
+      else if (!path.includes("."))
+        addKeys(r);
+    }
+  }
+  return Array.from(set);
+}
 // src/catalog/storage/storageCapabilities.ts
 var contentTypeField = {
   key: "contentType",
@@ -5462,6 +5813,7 @@ var CONFIG_CONTRACTS = {
     }
   },
   transform: { schema: TransformConfig.schema, validate: asValidator(TransformConfig.validate) },
+  aggregate: { schema: AggregateConfig.schema, validate: asValidator(AggregateConfig.validate) },
   condition: { schema: ConditionConfig.schema, validate: asValidator(ConditionConfig.validate) },
   for_each: { schema: ForEachConfig.schema, validate: asValidator(ForEachConfig.validate) },
   file_operation: { schema: FileOperationConfig.schema, validate: asValidator(FileOperationConfig.validate) },
@@ -5813,9 +6165,12 @@ function mappingTransformFunctionName(transform) {
   return match ? match[1] : null;
 }
 export {
+  AGGREGATE_FUNCTIONS,
+  AGGREGATE_FUNCTION_DESCRIPTIONS,
   ActionCategory,
   ActionStatus,
   ActionType,
+  AggregateConfig,
   AggregateFunction,
   AiAgentConfig,
   CONDITION_OPERATORS,
@@ -5887,6 +6242,7 @@ export {
   contractFor,
   contractVocabularyDrift,
   declaredKeys,
+  detectRecordFields,
   emailDefinition,
   fileEditErrors,
   fileFormatErrors,
@@ -5904,6 +6260,7 @@ export {
   getNodeConfigStatus,
   getNodeValidationStatus,
   getStorageProvider,
+  groupKeyName,
   inferSchemaFromSample,
   isEditorPrivateKey,
   isEventCapableConnector,
@@ -5912,6 +6269,7 @@ export {
   mappingTransformFunctionName,
   migrateDelayConfig,
   queryDefinition,
+  resolveRecordSchema,
   selectsWithoutValues,
   storageConfigKeys,
   storageOperations,

package/dist/rules/configContracts.d.ts

@@ -70,10 +70,10 @@ export interface ConfigContract {
     };
 }
 /**
- * Every action in the catalog, keyed by action id — since 0.11.0 all 37
+ * Every action in the catalog, keyed by action id — since 0.11.0 all
  * definitions carry one (the last fifteen: group, ai_agent, idp_extract,
  * connector_trigger, the five file-format actions and the six storage
- * actions). `contractFor` is undefined only for an id the catalog does not
+ * actions; 0.13.0 added `aggregate`, the 38th). `contractFor` is undefined only for an id the catalog does not
  * know, and then consumers fall back to `inputSchema` alone. A new action is
  * a `config.ts` plus one line here; the drift test covers it from then on.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octaviaflow/flow-rules",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "The flow action catalog and the rules engine behind Flow Doctor — one definition of what a step accepts and what makes a flow valid, shared by the editor and the server",
   "type": "module",
   "main": "./dist/index.cjs",