@octaviaflow/flow-rules 0.11.1 → 0.13.0

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";
@@ -1256,8 +1257,18 @@ function isQueryableConnector(connector) {
 }
 var BuildQueryContractSchema = {
   connectorId: { type: "connection", required: true },
-  mode: { type: "select", required: true },
-  queryType: { type: "select", required: true },
+  mode: {
+    type: "select",
+    required: true,
+    options: ["visual", "sql"],
+    description: "visual: the query is built from visualConfig; sql: the query is the text in sqlConfig.sql"
+  },
+  queryType: {
+    type: "select",
+    required: true,
+    options: ["select", "insert", "update", "delete", "custom"],
+    description: "Only select is a read; the write types exist for the SQL mode of database connectors"
+  },
   visualConfig: { type: "object", required: false },
   sqlConfig: { type: "object", required: false },
   timeout: { type: "number", required: false },
@@ -1577,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",
@@ -2636,7 +2687,8 @@ var actionsRegistry = {
     console_log: consoleLogDefinition,
     delay: delayDefinition,
     query: queryDefinition,
-    transform: transformDefinition
+    transform: transformDefinition,
+    aggregate: aggregateDefinition
   },
   ["logic" /* Logic */]: {
     condition: conditionDefinition,
@@ -3157,7 +3209,7 @@ var ConditionConfig = {
     condition: ""
   },
   schema: {
-    mode: { type: "select", required: true },
+    mode: { type: "select", required: true, options: ["visual", "expression"] },
     filters: { type: "array", required: false },
     condition: { type: "expression", required: false }
   },
@@ -3227,8 +3279,18 @@ var ForEachConfig = {
     collect: "array"
   },
   schema: {
-    arrayPath: { type: "select", required: false },
-    iterationMode: { type: "select", required: false },
+    arrayPath: {
+      type: "select",
+      required: false,
+      dynamic: true,
+      description: "A path to an array in the upstream step's output (the Query's object name, or a field holding a list) — the values come from that step's data, not from the catalog"
+    },
+    iterationMode: {
+      type: "select",
+      required: false,
+      options: ["records", "fields", "range", "nested", "batch", "cursor", "while", "array"],
+      description: "What one iteration is: records (one per record, the default; array is its legacy alias), fields, range, nested, batch, cursor or while"
+    },
     itemVariable: { type: "string", required: true },
     indexVariable: { type: "string", required: false },
     batchSize: { type: "number", required: false },
@@ -3432,7 +3494,7 @@ function fieldToJsonSchema(f) {
 // src/catalog/utility/debug/config.ts
 var DebugConfig = {
   schema: {
-    mode: { type: "select", required: true },
+    mode: { type: "select", required: true, options: ["log", "snapshot", "watch", "assert", "profile"] },
     label: { type: "string", required: false },
     pinned: { type: "boolean", required: false },
     condition: { type: "expression", required: false },
@@ -3547,7 +3609,12 @@ var EmailConfig = {
   },
   schema: {
     connection: { type: "connection", required: true },
-    operation: { type: "select", required: true },
+    operation: {
+      type: "select",
+      required: true,
+      options: ["send", "read", "search", "delete", "move", "mark_read"],
+      description: "Only send runs today (DEV-349); the other values are kept so older steps still parse, and validate() rejects them"
+    },
     to: { type: "string", required: false },
     cc: { type: "string", required: false },
     bcc: { type: "string", required: false },
@@ -3599,13 +3666,18 @@ 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 = [
   { id: "upsert", label: "Upsert" },
   { id: "insert", label: "Insert" },
   { id: "update", label: "Update" },
   { id: "delete", label: "Delete" }
 ];
+var TRANSFORM_OPERATION_IDS = TRANSFORM_OPERATIONS.map((o) => o.id);
 var DATABASE_CONNECTOR_IDS = new Set(["mongodb", "postgresql", "mysql", "sqlite", "google_sheets"]);
 var TransformConfig = {
   defaults: {
@@ -3629,11 +3701,30 @@ var TransformConfig = {
   },
   schema: {
     name: { type: "string", required: false },
-    operation: { type: "select", required: true },
+    operation: {
+      type: "select",
+      required: true,
+      options: TRANSFORM_OPERATION_IDS,
+      description: "What to do with each mapped record at the target: upsert, insert, update or delete"
+    },
     connectorId: { type: "connection", required: true },
-    database: { type: "text", required: false },
-    objectName: { type: "select", required: true },
-    mode: { type: "select", required: true },
+    database: {
+      type: "text",
+      required: false,
+      description: "Database name for MongoDB / PostgreSQL / MySQL / SQLite; the spreadsheet id for Google Sheets"
+    },
+    objectName: {
+      type: "select",
+      required: true,
+      dynamic: true,
+      description: "The table, entity, object or sheet tab to write to — the names come from the connected app (describe_connector_object)"
+    },
+    mode: {
+      type: "select",
+      required: true,
+      options: TRANSFORM_MODES,
+      description: "How the mappings are authored: visual (the Field Mapper — the only mode the editor offers) or expression (legacy JavaScript). This is not the write mode; that is `operation`."
+    },
     mappings: { type: "array", required: false },
     expression: { type: "code", required: false }
   },
@@ -3647,6 +3738,12 @@ var TransformConfig = {
     const errors = [];
     if (!config.operation) {
       errors.push("Operation is required");
+    } else if (!isOneOf(TRANSFORM_OPERATION_IDS, config.operation)) {
+      errors.push(`Operation must be one of: ${TRANSFORM_OPERATION_IDS.join(", ")} (got "${String(config.operation)}")`);
+    }
+    const mode = config.mode;
+    if (mode !== undefined && mode !== null && mode !== "" && !isOneOf(TRANSFORM_MODES, mode)) {
+      errors.push(`Mode must be one of: ${TRANSFORM_MODES.join(", ")} (got "${String(mode)}"). ` + `Mode is how the mappings are authored, not how rows are written — for that, see operation.`);
     }
     if (!config.connectorId) {
       errors.push("Target connector is required");
@@ -3682,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",
@@ -4850,6 +5254,7 @@ var ConsoleLogConfig = {
     level: {
       type: "select",
       required: false,
+      options: ["info", "warning", "error", "debug"],
       description: "Log level for the message"
     },
     data: {
@@ -4900,6 +5305,7 @@ var DelayConfig = {
     unit: {
       type: "select",
       required: false,
+      options: ["milliseconds", "seconds", "minutes", "hours"],
       description: "Time unit for the duration"
     }
   },
@@ -4964,10 +5370,10 @@ var HTTPRequestConfig = {
     expectedContentTypes: []
   },
   schema: {
-    apiType: { type: "select", required: false },
+    apiType: { type: "select", required: false, options: ["rest", "graphql"] },
     baseUrl: { type: "string", required: false },
     queryParams: { type: "array", required: false },
-    bodyType: { type: "select", required: false },
+    bodyType: { type: "select", required: false, options: ["none", "json", "raw", "form-data", "xml"] },
     formData: { type: "array", required: false },
     graphqlQuery: { type: "code", required: false },
     graphqlVariables: { type: "json", required: false },
@@ -4977,11 +5383,12 @@ var HTTPRequestConfig = {
     retry: { type: "object", required: false },
     pagination: { type: "object", required: false },
     extract: { type: "object", required: false },
-    responseType: { type: "select", required: false },
+    responseType: { type: "select", required: false, options: ["json", "text", "binary"] },
     expectedContentTypes: { type: "array", required: false },
     method: {
       type: "select",
       required: true,
+      options: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
       description: "HTTP method to use"
     },
     url: {
@@ -5171,7 +5578,7 @@ var WebhookCallConfig = {
   },
   schema: {
     url: { type: "url", required: true },
-    method: { type: "select", required: true },
+    method: { type: "select", required: true, options: ["POST", "PUT", "PATCH", "GET"] },
     payload: { type: "json", required: false },
     headers: { type: "json", required: false }
   },
@@ -5196,7 +5603,7 @@ var WhatsappSendConfig = {
   schema: {
     connection: { type: "connection", required: true },
     to: { type: "string", required: true },
-    mode: { type: "select", required: true },
+    mode: { type: "select", required: true, options: ["template", "text"] },
     templateName: { type: "string", required: false },
     templateLanguage: { type: "string", required: false },
     templateVariables: { type: "array", required: false },
@@ -5243,7 +5650,7 @@ var FileOperationConfig = {
   },
   schema: {
     connection: { type: "connection", required: true },
-    operation: { type: "select", required: true },
+    operation: { type: "select", required: true, options: ["upload", "download", "delete", "list", "copy", "move", "exists"] },
     sourcePath: { type: "string", required: false },
     destinationPath: { type: "string", required: true },
     fileContent: { type: "string", required: false },
@@ -5277,7 +5684,7 @@ var FormatConfig = {
   defaults: { input: "", format: "json" },
   schema: {
     input: { type: "expression", required: true },
-    format: { type: "select", required: true }
+    format: { type: "select", required: true, options: ["json", "csv", "xml", "yaml"] }
   },
   validate: (config) => {
     const errors = [];
@@ -5302,9 +5709,9 @@ var ScheduleTriggerConfig = {
     timezone: "UTC"
   },
   schema: {
-    scheduleType: { type: "select", required: true },
+    scheduleType: { type: "select", required: true, options: ["interval", "cron", "specific"] },
     interval: { type: "number", required: false, min: 1 },
-    intervalUnit: { type: "select", required: false },
+    intervalUnit: { type: "select", required: false, options: ["minutes", "hours", "days", "weeks"] },
     cronExpression: { type: "string", required: false },
     timezone: { type: "string", required: false }
   },
@@ -5342,7 +5749,7 @@ var WebhookTriggerConfig = {
   },
   schema: {
     webhookPath: { type: "string", required: false },
-    method: { type: "select", required: true },
+    method: { type: "select", required: true, options: ["GET", "POST", "PUT", "PATCH", "DELETE"] },
     requireAuth: { type: "boolean", required: false }
   },
   validate: (config) => {
@@ -5406,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) },
@@ -5476,11 +5884,18 @@ function contractFieldsFor(definition) {
       label: humanise(key),
       type: CONTRACT_TYPE_TO_FIELD_TYPE[field.type] ?? "string" /* String */,
       validation: { required: field.required === true },
+      ...typeof field.description === "string" && field.description ? { description: field.description } : {},
       ...field.options ? { options: field.options.map((v) => ({ label: String(v), value: v })) } : {}
     });
   }
   return [...declared, ...derived];
 }
+function selectsWithoutValues(actionId) {
+  const contract = contractFor(actionId);
+  if (!contract)
+    return [];
+  return Object.entries(contract.schema).filter(([, f]) => f.type === "select" && !(f.options && f.options.length > 0) && f.dynamic !== true).map(([key]) => key);
+}
 function contractDrift(definition) {
   const contract = contractFor(definition.id);
   if (!contract)
@@ -5750,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,
@@ -5807,6 +6225,7 @@ export {
   STORAGE_CONNECTOR_IDS,
   SortDirection,
   StorageActionConfig,
+  TRANSFORM_MODES,
   TRANSFORM_OPERATIONS,
   TransformConfig,
   USER_FUNCTION_PREFIX,
@@ -5823,6 +6242,7 @@ export {
   contractFor,
   contractVocabularyDrift,
   declaredKeys,
+  detectRecordFields,
   emailDefinition,
   fileEditErrors,
   fileFormatErrors,
@@ -5840,6 +6260,7 @@ export {
   getNodeConfigStatus,
   getNodeValidationStatus,
   getStorageProvider,
+  groupKeyName,
   inferSchemaFromSample,
   isEditorPrivateKey,
   isEventCapableConnector,
@@ -5848,6 +6269,8 @@ export {
   mappingTransformFunctionName,
   migrateDelayConfig,
   queryDefinition,
+  resolveRecordSchema,
+  selectsWithoutValues,
   storageConfigKeys,
   storageOperations,
   summarizeConnectorTriggerEvents,