@octaviaflow/flow-rules 0.12.0 → 0.13.1

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";
@@ -1373,7 +1374,7 @@ var queryDefinition = {
         key: "visualConfig.limit",
         label: "Limit",
         type: "number" /* Number */,
-        description: "Maximum number of rows to return",
+        description: "Rows the PREVIEW shows. A run never reads it — set visualConfig.maxRows to cap a run.",
         defaultValue: 10,
         validation: { required: false, min: 1, max: 1e4 },
         conditional: [
@@ -1385,6 +1386,22 @@ var queryDefinition = {
           }
         ]
       },
+      {
+        key: "visualConfig.maxRows",
+        label: "Max rows (run)",
+        type: "number" /* Number */,
+        description: "The most rows a run reads (up to 10,000). Unset: 10,000. The Limit above is preview-only.",
+        validation: { required: false, min: 1, max: 1e4 },
+        advanced: true,
+        conditional: [
+          {
+            field: "mode",
+            operator: "==",
+            value: "visual" /* Visual */,
+            action: "show"
+          }
+        ]
+      },
       {
         key: "sqlConfig.sql",
         label: "SQL Query",
@@ -1431,7 +1448,7 @@ var queryDefinition = {
         key: "maxRows",
         label: "Max Rows",
         type: "number" /* Number */,
-        description: "Maximum number of rows to return",
+        description: "Legacy step-level field — NOT read at run. Cap a visual Query with visualConfig.maxRows; in SQL mode write a LIMIT.",
         defaultValue: 1000,
         validation: { required: false, min: 1, max: 1e4 },
         advanced: true
@@ -1587,6 +1604,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",
@@ -2508,7 +2565,7 @@ var graphqlQueryDefinition = {
 var aiAgentDefinition = {
   id: "ai_agent",
   name: "AI Agent",
-  description: "Run a reusable AI agent. Pick a saved agent from /ai/agents; optionally override model, temperature, or instructions per step.",
+  description: "Run a reusable AI agent. Pick a saved agent from /ai/agents; optionally override model, temperature, or instructions per step. " + "When the step before it produces rows (a Query, a Transform), the agent runs ONCE PER ROW with the prompt as the per-row template — " + "reference single fields, never the whole table; put an Aggregate first to call it once. maxRows (default 50) caps the calls.",
   category: "ai" /* AI */,
   type: "ai_agent" /* AIAgent */,
   tags: ["ai", "agent", "chat", "built-in"],
@@ -2528,21 +2585,28 @@ var aiAgentDefinition = {
         key: "input",
         label: "Input",
         type: "string" /* String */,
-        description: "Chat agents: a string (template-supported via {{step.field}}). ETL agents: rows array. When blank, falls back to upstream step output."
+        description: "The prompt. Over a row-shaped upstream it is the per-row template: each data reference resolves to the current row. " + "A reference to the whole upstream table is refused. When blank, the upstream output is the input."
       },
       {
         key: "overrides",
         label: "Overrides",
         type: "json" /* JSON */,
         description: "Optional per-step overrides of the agent’s own settings: model, temperature, maxTokens, topP, instructions and instructionsMode."
+      },
+      {
+        key: "maxRows",
+        label: "Max rows",
+        type: "number" /* Number */,
+        description: "Per-row mode: the most model calls this step may make, one per upstream row (default 50, at most 1000)."
       }
     ]
   },
   outputSchema: {
     type: "object",
     properties: [
-      { key: "text", type: "string" /* String */, description: "Agent response text (chat agents)" },
-      { key: "rows", type: "json" /* JSON */, description: "Output rows (etl agents)" },
+      { key: "text", type: "string" /* String */, description: "Agent response text; in per-row mode, one line per row" },
+      { key: "output", type: "json" /* JSON */, description: "The parsed answer (an object when the agent replies in JSON); in per-row mode, one entry per row" },
+      { key: "rows", type: "json" /* JSON */, description: "Per-row mode: one entry per upstream row" },
       { key: "usage", type: "json" /* JSON */, description: "Token usage + cost: tokensIn, tokensOut, latencyMs, costUsd" },
       { key: "model", type: "string" /* String */, description: "Model that produced the response" },
       { key: "agentVersion", type: "number" /* Number */, description: "Version of the agent definition that ran" }
@@ -2646,7 +2710,8 @@ var actionsRegistry = {
     console_log: consoleLogDefinition,
     delay: delayDefinition,
     query: queryDefinition,
-    transform: transformDefinition
+    transform: transformDefinition,
+    aggregate: aggregateDefinition
   },
   ["logic" /* Logic */]: {
     condition: conditionDefinition,
@@ -3624,6 +3689,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 +3701,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 +3802,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}} in a Transform mapping. " + "A message or AI prompt reads it as {{ods://steps/<this step id>/output/data[0]/TotalAmount}} — the mapping form is not resolved there. " + "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",
@@ -3804,7 +4178,18 @@ var STORAGE_PROVIDERS = {
     operations: [
       { value: "list", label: "List files", path: { key: "folderId", label: "Folder", selectMode: "folder" }, fields: [{ key: "query", label: "Search query", type: "string", advanced: true }, { key: "pageSize", label: "Max results", type: "number", defaultValue: 50, advanced: true }] },
       { value: "download", label: "Download file", path: { key: "fileId", label: "File", selectMode: "both", required: true } },
-      { value: "upload", label: "Upload file", path: { key: "folderId", label: "Destination folder", selectMode: "both" }, content: true, fields: [{ key: "fileName", label: "File name", type: "string", required: true }, { key: "mimeType", label: "Content type", type: "string", advanced: true }] },
+      {
+        value: "upload",
+        label: "Upload file",
+        path: { key: "folderId", label: "Destination folder", selectMode: "both" },
+        content: true,
+        fields: [
+          { key: "fileName", label: "File name", type: "string", required: true },
+          { key: "folderName", label: "Folder path", type: "string", advanced: true, placeholder: "Reports/2026", hint: "Folders under My Drive, separated by /. Missing ones are created on the first run. Ignored when a destination folder is picked." },
+          { key: "ifExists", label: "If the file already exists", type: "select", options: [{ label: "Replace it (Drive keeps the versions)", value: "overwrite" }, { label: "Skip it", value: "skip" }, { label: "Keep both (rename)", value: "rename" }], defaultValue: "overwrite", advanced: true },
+          { key: "mimeType", label: "Content type", type: "string", advanced: true }
+        ]
+      },
       { value: "delete", label: "Delete file", path: { key: "fileId", label: "File", selectMode: "both", required: true } },
       { value: "move", label: "Move", path: { key: "fileId", label: "File", selectMode: "both", required: true }, dest: { key: "destFolderId", label: "Destination folder", selectMode: "both", required: true } },
       { value: "copy", label: "Copy", path: { key: "fileId", label: "File", selectMode: "both", required: true }, dest: { key: "destFolderId", label: "Destination folder", selectMode: "both" }, fields: [{ key: "fileName", label: "New name", type: "string" }] },
@@ -3923,7 +4308,13 @@ var AiAgentConfig = {
   schema: {
     agentId: { type: "string", required: true, description: "Public id of a saved agent (agt_…)" },
     input: { type: "text", required: false, description: "The prompt; may reference upstream data with {{ods://…}} tokens. Empty uses the first upstream output." },
-    overrides: { type: "object", required: false, description: "Per-step overrides: model, temperature, topP, maxTokens, reasoningEffort, verbosity, batchSize, instructions, instructionsMode, expectedSchema" }
+    overrides: { type: "object", required: false, description: "Per-step overrides: model, temperature, topP, maxTokens, reasoningEffort, verbosity, batchSize, instructions, instructionsMode, expectedSchema" },
+    maxRows: {
+      type: "number",
+      required: false,
+      min: 1,
+      description: "Per-row mode: the most model calls this step may make, one per upstream row (default 50, at most 1000). More rows stop the step before any call."
+    }
   },
   validate: (config) => {
     const errors = [];
@@ -3932,6 +4323,9 @@ var AiAgentConfig = {
     if (config.overrides !== undefined && (typeof config.overrides !== "object" || config.overrides === null || Array.isArray(config.overrides))) {
       errors.push("overrides must be an object");
     }
+    if (config.maxRows !== undefined && !(Number.isInteger(config.maxRows) && config.maxRows >= 1 && config.maxRows <= 1000)) {
+      errors.push("maxRows must be a whole number from 1 to 1000");
+    }
     return { valid: errors.length === 0, errors };
   },
   merge: (userConfig) => ({ ...AiAgentConfig.defaults, ...userConfig }),
@@ -5462,6 +5856,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 +6208,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 +6285,7 @@ export {
   contractFor,
   contractVocabularyDrift,
   declaredKeys,
+  detectRecordFields,
   emailDefinition,
   fileEditErrors,
   fileFormatErrors,
@@ -5904,6 +6303,7 @@ export {
   getNodeConfigStatus,
   getNodeValidationStatus,
   getStorageProvider,
+  groupKeyName,
   inferSchemaFromSample,
   isEditorPrivateKey,
   isEventCapableConnector,
@@ -5912,6 +6312,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.1",
   "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",