@octaviaflow/flow-rules 0.7.0 → 0.8.1

package/dist/index.cjs

@@ -44,6 +44,7 @@ __export(exports_src, {
   ActionType: () => ActionType,
   AggregateFunction: () => AggregateFunction,
   CONDITION_OPERATORS: () => CONDITION_OPERATORS,
+  CONFIG_CONTRACTS: () => CONFIG_CONTRACTS,
   ConditionConfig: () => ConditionConfig,
   DATABASE_CONNECTOR_IDS: () => DATABASE_CONNECTOR_IDS,
   DebugConfig: () => DebugConfig,
@@ -71,6 +72,12 @@ __export(exports_src, {
   collectArrayPaths: () => collectArrayPaths,
   collectArrayPathsFromSample: () => collectArrayPathsFromSample,
   configErrors: () => configErrors,
+  contractDerivedKeys: () => contractDerivedKeys,
+  contractDrift: () => contractDrift,
+  contractFieldsFor: () => contractFieldsFor,
+  contractFor: () => contractFor,
+  contractVocabularyDrift: () => contractVocabularyDrift,
+  declaredKeys: () => declaredKeys,
   emailDefinition: () => emailDefinition,
   flattenNestedWorkflow: () => flattenNestedWorkflow,
   generateConnectionsFromSteps: () => generateConnectionsFromSteps,
@@ -86,6 +93,7 @@ __export(exports_src, {
   getNodeValidationStatus: () => getNodeValidationStatus,
   getStorageProvider: () => getStorageProvider,
   inferSchemaFromSample: () => inferSchemaFromSample,
+  isEditorPrivateKey: () => isEditorPrivateKey,
   isMappingFunction: () => isMappingFunction,
   isQueryableConnector: () => isQueryableConnector,
   mappingTransformFunctionName: () => mappingTransformFunctionName,
@@ -1192,6 +1200,149 @@ var BuildQueryConfigDefaults = {
     parameters: {}
   }
 };
+var validateBuildQueryConfig = (config) => {
+  const errors = [];
+  const warnings = [];
+  if (!config.connectorId) {
+    errors.push({
+      field: "connectorId",
+      message: "Please select a connector",
+      severity: "error"
+    });
+  }
+  if (!config.mode) {
+    errors.push({
+      field: "mode",
+      message: "Query mode is required",
+      severity: "error"
+    });
+  }
+  if (!config.queryType) {
+    errors.push({
+      field: "queryType",
+      message: "Query type is required",
+      severity: "error"
+    });
+  }
+  if (config.mode === "visual" /* Visual */) {
+    const visualErrors = validateVisualQueryConfig(config.visualConfig);
+    errors.push(...visualErrors);
+  } else if (config.mode === "sql" /* SQL */) {
+    const sqlErrors = validateSQLQueryConfig(config.sqlConfig);
+    errors.push(...sqlErrors);
+  }
+  if (config.timeout !== undefined) {
+    if (config.timeout < 1000) {
+      errors.push({
+        field: "timeout",
+        message: "Timeout must be at least 1000ms",
+        severity: "error"
+      });
+    } else if (config.timeout > 300000) {
+      warnings.push({
+        field: "timeout",
+        message: "Timeout is very high (>5 minutes)",
+        severity: "warning"
+      });
+    }
+  }
+  if (config.maxRows !== undefined) {
+    if (config.maxRows < 1) {
+      errors.push({
+        field: "maxRows",
+        message: "Max rows must be at least 1",
+        severity: "error"
+      });
+    } else if (config.maxRows > 1e4) {
+      warnings.push({
+        field: "maxRows",
+        message: "Max rows is very high (>10,000). This may impact performance.",
+        severity: "warning"
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+};
+var validateVisualQueryConfig = (config) => {
+  const errors = [];
+  if (!config) {
+    errors.push({
+      field: "visualConfig",
+      message: "Visual query configuration is required",
+      severity: "error"
+    });
+    return errors;
+  }
+  if (!config.tables || config.tables.length === 0) {
+    errors.push({
+      field: "visualConfig.tables",
+      message: "At least one table must be selected",
+      severity: "error"
+    });
+  }
+  if (!config.fields || config.fields.length === 0) {
+    errors.push({
+      field: "visualConfig.fields",
+      message: "At least one field must be selected",
+      severity: "error"
+    });
+  }
+  if (config.tables && config.tables.length > 1) {
+    if (!config.joins || config.joins.length === 0) {
+      errors.push({
+        field: "visualConfig.joins",
+        message: "Joins are required when selecting from multiple tables",
+        severity: "error"
+      });
+    }
+  }
+  const hasAggregates = config.fields?.some((field) => field.aggregate);
+  const hasNonAggregates = config.fields?.some((field) => !field.aggregate);
+  if (hasAggregates && hasNonAggregates) {
+    if (!config.groupBy || config.groupBy.length === 0) {
+      errors.push({
+        field: "visualConfig.groupBy",
+        message: "Group by is required when mixing aggregate and non-aggregate fields",
+        severity: "error"
+      });
+    }
+  }
+  return errors;
+};
+var validateSQLQueryConfig = (config) => {
+  const errors = [];
+  if (!config) {
+    errors.push({
+      field: "sqlConfig",
+      message: "SQL query configuration is required",
+      severity: "error"
+    });
+    return errors;
+  }
+  if (!config.sql || config.sql.trim().length === 0) {
+    errors.push({
+      field: "sqlConfig.sql",
+      message: "SQL query is required",
+      severity: "error"
+    });
+  } else {
+    const sql = config.sql.trim().toLowerCase();
+    const dangerousKeywords = ["drop", "truncate", "alter", "create", "grant", "revoke"];
+    const hasDangerousKeyword = dangerousKeywords.some((keyword) => sql.includes(keyword + " "));
+    if (hasDangerousKeyword) {
+      errors.push({
+        field: "sqlConfig.sql",
+        message: "SQL query contains potentially dangerous operations (DROP, TRUNCATE, ALTER, etc.)",
+        severity: "error"
+      });
+    }
+  }
+  return errors;
+};
 function isQueryableConnector(connector) {
   if (connector.isQueryable !== undefined) {
     return connector.isQueryable;
@@ -1217,6 +1368,15 @@ function isQueryableConnector(connector) {
   ];
   return !storageTypes.includes(connector.type.toLowerCase());
 }
+var BuildQueryContractSchema = {
+  connectorId: { type: "connection", required: true },
+  mode: { type: "select", required: true },
+  queryType: { type: "select", required: true },
+  visualConfig: { type: "object", required: false },
+  sqlConfig: { type: "object", required: false },
+  timeout: { type: "number", required: false },
+  maxRows: { type: "number", required: false }
+};
 
 // src/catalog/general/query/index.ts
 var queryDefinition = {
@@ -2106,7 +2266,7 @@ var slackMessageDefinition = {
     fields: [
       { key: "connection", label: "Slack Workspace", type: "connection" /* Connection */, validation: { required: true } },
       { key: "channel", label: "Channel/User", type: "string" /* String */, validation: { required: true } },
-      { key: "message", label: "Message", type: "string" /* String */, validation: { required: true } },
+      { key: "text", label: "Message", type: "string" /* String */, validation: { required: true } },
       { key: "blocks", label: "Blocks (JSON)", type: "json" /* JSON */, validation: { required: false } }
     ]
   },
@@ -3330,6 +3490,9 @@ function buildPathOptions(upstreamNodes) {
 var RESERVED_KEYS = new Set(["_lineage", "_meta", "_redacted", "_error"]);
 var KEY_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 var VariablesConfig = {
+  schema: {
+    fields: { type: "array", required: true }
+  },
   defaults: {
     fields: []
   },
@@ -3380,6 +3543,18 @@ function fieldToJsonSchema(f) {
 }
 // src/catalog/utility/debug/config.ts
 var DebugConfig = {
+  schema: {
+    mode: { type: "select", required: true },
+    label: { type: "string", required: false },
+    pinned: { type: "boolean", required: false },
+    condition: { type: "expression", required: false },
+    sampling: { type: "object", required: false },
+    log: { type: "object", required: false },
+    snapshot: { type: "object", required: false },
+    watch: { type: "object", required: false },
+    assert: { type: "object", required: false },
+    profile: { type: "object", required: false }
+  },
   defaults: {
     mode: "log",
     label: "",
@@ -3565,6 +3740,7 @@ var TransformConfig = {
     sheetColumns: ""
   },
   schema: {
+    name: { type: "string", required: false },
     operation: { type: "select", required: true },
     connectorId: { type: "connection", required: true },
     database: { type: "text", required: false },
@@ -4102,6 +4278,665 @@ function validateFlowData(flow) {
   const f = flow;
   return typeof f.id === "string" && typeof f.name === "string" && f.workflow !== undefined && typeof f.workflow === "object" && f.workflow !== null && Array.isArray(f.workflow.steps);
 }
+// src/catalog/actions/console-log/config.ts
+var ConsoleLogConfig = {
+  defaults: {
+    message: "",
+    level: "info",
+    data: undefined,
+    includeInputData: true
+  },
+  schema: {
+    includeInputData: { type: "boolean", required: false },
+    message: {
+      type: "string",
+      required: true,
+      description: "Message to log"
+    },
+    level: {
+      type: "select",
+      required: false,
+      description: "Log level for the message"
+    },
+    data: {
+      type: "json",
+      required: false,
+      description: "Additional data to log"
+    }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.message) {
+      errors.push("Message is required");
+    } else if (typeof config.message !== "string") {
+      errors.push("Message must be a string");
+    }
+    if (config.level && !["info", "warning", "error", "debug"].includes(config.level)) {
+      errors.push("Invalid log level");
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  },
+  merge: (userConfig) => {
+    return {
+      ...ConsoleLogConfig.defaults,
+      ...userConfig
+    };
+  },
+  getLabel: (config) => {
+    return `Log [${config.level}]: ${config.message}`;
+  }
+};
+
+// src/catalog/actions/delay/config.ts
+var DelayConfig = {
+  defaults: {
+    duration: 1000,
+    unit: "milliseconds"
+  },
+  schema: {
+    duration: {
+      type: "number",
+      required: true,
+      description: "Duration to delay",
+      min: 0
+    },
+    unit: {
+      type: "select",
+      required: false,
+      description: "Time unit for the duration"
+    }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (config.duration === undefined || config.duration === null) {
+      errors.push("Duration is required");
+    } else if (typeof config.duration !== "number") {
+      errors.push("Duration must be a number");
+    } else if (config.duration < 0) {
+      errors.push("Duration must be non-negative");
+    }
+    if (config.unit && !["milliseconds", "seconds", "minutes", "hours"].includes(config.unit)) {
+      errors.push("Invalid time unit");
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  },
+  toMilliseconds: (duration, unit = "milliseconds") => {
+    const multipliers = {
+      milliseconds: 1,
+      seconds: 1000,
+      minutes: 60000,
+      hours: 3600000
+    };
+    return duration * (multipliers[unit] || 1);
+  },
+  merge: (userConfig) => {
+    return {
+      ...DelayConfig.defaults,
+      ...userConfig
+    };
+  },
+  getLabel: (config) => {
+    return `Delay ${config.duration}${config.unit ? " " + config.unit : "ms"}`;
+  }
+};
+
+// src/catalog/actions/http-request/config.ts
+var HTTPRequestConfig = {
+  defaults: {
+    apiType: "rest",
+    method: "GET",
+    url: "",
+    queryParams: [],
+    headers: [],
+    bodyType: "json",
+    body: undefined,
+    formData: [],
+    graphqlQuery: "",
+    graphqlVariables: {},
+    auth: { type: "none" },
+    timeout: 30000,
+    failOnError: true,
+    followRedirects: true,
+    retry: { maxAttempts: 1, retryOn: [429, 500, 502, 503, 504], initialDelayMs: 1000, backoffFactor: 2, maxDelayMs: 30000 },
+    pagination: { type: "none" },
+    extract: {},
+    responseType: "json",
+    expectedContentTypes: []
+  },
+  schema: {
+    apiType: { type: "select", required: false },
+    baseUrl: { type: "string", required: false },
+    queryParams: { type: "array", required: false },
+    bodyType: { type: "select", required: false },
+    formData: { type: "array", required: false },
+    graphqlQuery: { type: "code", required: false },
+    graphqlVariables: { type: "json", required: false },
+    auth: { type: "object", required: false },
+    failOnError: { type: "boolean", required: false },
+    followRedirects: { type: "boolean", required: false },
+    retry: { type: "object", required: false },
+    pagination: { type: "object", required: false },
+    extract: { type: "object", required: false },
+    responseType: { type: "select", required: false },
+    expectedContentTypes: { type: "array", required: false },
+    method: {
+      type: "select",
+      required: true,
+      description: "HTTP method to use"
+    },
+    url: {
+      type: "url",
+      required: true,
+      description: "The URL to send the request to"
+    },
+    headers: {
+      type: "json",
+      required: false,
+      description: "HTTP headers to send with the request"
+    },
+    body: {
+      type: "json",
+      required: false,
+      description: "Request body (for POST, PUT, PATCH)"
+    },
+    timeout: {
+      type: "number",
+      required: false,
+      description: "Request timeout in milliseconds",
+      min: 1000
+    }
+  },
+  validate: (config) => {
+    const errors = [];
+    const apiType = config.apiType ?? "rest";
+    if (apiType === "rest" && !config.method) {
+      errors.push("Method is required");
+    }
+    if (apiType === "graphql" && !config.graphqlQuery?.trim()) {
+      errors.push("GraphQL query is required");
+    }
+    if (!config.url) {
+      errors.push("URL is required");
+    } else if (typeof config.url === "string") {
+      try {
+        new URL(config.url);
+      } catch {
+        errors.push("Invalid URL format");
+      }
+    }
+    if (config.timeout !== undefined && typeof config.timeout === "number") {
+      if (config.timeout < 1000) {
+        errors.push("Timeout must be at least 1000ms");
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  },
+  merge: (userConfig) => {
+    return {
+      ...HTTPRequestConfig.defaults,
+      ...userConfig
+    };
+  },
+  getLabel: (config) => {
+    const type = config.apiType === "graphql" ? "GraphQL" : config.method ?? "GET";
+    return `${type} ${config.url}`;
+  }
+};
+
+// src/catalog/api/graphql-query/config.ts
+var GraphQLQueryConfig = {
+  defaults: {
+    endpoint: "",
+    query: "",
+    variables: {},
+    headers: {}
+  },
+  schema: {
+    endpoint: { type: "url", required: true },
+    query: { type: "code", required: true },
+    variables: { type: "json", required: false },
+    headers: { type: "json", required: false }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.endpoint)
+      errors.push("Endpoint is required");
+    if (!config.query)
+      errors.push("Query is required");
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...GraphQLQueryConfig.defaults, ...userConfig };
+  },
+  getLabel: (config) => {
+    return `GraphQL: ${config.endpoint}`;
+  }
+};
+
+// src/catalog/communication/google-chat/config.ts
+var GoogleChatConfig = {
+  defaults: { connection: "", space: "", spaceName: "", text: "", threadKey: "" },
+  schema: {
+    connection: { type: "connection", required: true },
+    space: { type: "string", required: true },
+    text: { type: "string", required: false },
+    threadKey: { type: "string", required: false }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.connection)
+      errors.push("Connect a Google Chat account");
+    if (!config.space)
+      errors.push("Pick a space");
+    if (!config.text && !config.message)
+      errors.push("Add a message");
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({
+    ...GoogleChatConfig.defaults,
+    ...userConfig
+  }),
+  getLabel: () => "Google Chat"
+};
+
+// src/catalog/communication/slack-message/config.ts
+var SlackMessageConfig = {
+  defaults: { connection: "", messageType: "channel", channel: "", channelName: "", text: "", blocks: undefined },
+  schema: {
+    connection: { type: "connection", required: true },
+    messageType: { type: "string", required: false },
+    channel: { type: "string", required: true },
+    text: { type: "string", required: false },
+    blocks: { type: "json", required: false }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.connection)
+      errors.push("Slack workspace connection is required");
+    if (!config.channel)
+      errors.push(config.messageType === "user" ? "A user is required" : "A channel is required");
+    const hasText = Boolean(config.text || config.message);
+    const hasBlocks = Array.isArray(config.blocks) && config.blocks.length > 0;
+    if (!hasText && !hasBlocks)
+      errors.push("Add a message or at least one block");
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...SlackMessageConfig.defaults, ...userConfig };
+  },
+  getLabel: (config) => {
+    const prefix = config.messageType === "user" ? "@" : "#";
+    return config.channelName ? `Slack: ${prefix}${config.channelName}` : config.channel ? `Slack: ${config.channel}` : "Slack";
+  }
+};
+
+// src/catalog/communication/teams-message/config.ts
+var TeamsMessageConfig = {
+  defaults: { connection: "", teamId: "", teamName: "", channelId: "", channelName: "", title: "", message: "" },
+  schema: {
+    connection: { type: "connection", required: true },
+    teamId: { type: "string", required: true },
+    channelId: { type: "string", required: true },
+    title: { type: "string", required: false },
+    message: { type: "string", required: true }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.connection)
+      errors.push("Connect a Microsoft Teams account");
+    if (!config.teamId)
+      errors.push("Pick a team");
+    if (!config.channelId)
+      errors.push("Pick a channel");
+    if (!config.message)
+      errors.push("Add a message");
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...TeamsMessageConfig.defaults, ...userConfig };
+  },
+  getLabel: (config) => config.channelName ? `Teams: #${config.channelName}` : "Teams"
+};
+
+// src/catalog/communication/webhook-call/config.ts
+var WebhookCallConfig = {
+  defaults: {
+    url: "",
+    method: "POST",
+    payload: {},
+    headers: {}
+  },
+  schema: {
+    url: { type: "url", required: true },
+    method: { type: "select", required: true },
+    payload: { type: "json", required: false },
+    headers: { type: "json", required: false }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.url)
+      errors.push("Webhook URL is required");
+    if (!config.method)
+      errors.push("HTTP method is required");
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...WebhookCallConfig.defaults, ...userConfig };
+  },
+  getLabel: (config) => {
+    return `${config.method}: ${config.url.substring(0, 40)}...`;
+  }
+};
+
+// src/catalog/communication/whatsapp-send/config.ts
+var WhatsappSendConfig = {
+  schema: {
+    connection: { type: "connection", required: true },
+    to: { type: "string", required: true },
+    mode: { type: "select", required: true },
+    templateName: { type: "string", required: false },
+    templateLanguage: { type: "string", required: false },
+    templateVariables: { type: "array", required: false },
+    text: { type: "string", required: false },
+    previewUrl: { type: "boolean", required: false }
+  },
+  defaults: {
+    connection: "",
+    to: "",
+    mode: "template",
+    templateLanguage: "en_US",
+    templateVariables: []
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.connection)
+      errors.push("Select a WhatsApp connection");
+    if (!config.to?.trim())
+      errors.push("Recipient phone number is required");
+    if (config.mode === "text") {
+      if (!config.text?.trim())
+        errors.push("Message text is required");
+    } else {
+      if (!config.templateName?.trim())
+        errors.push("Choose an approved template");
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...WhatsappSendConfig.defaults, ...userConfig };
+  },
+  getLabel: (config) => config.mode === "text" ? `WhatsApp to ${config.to || "—"}` : `WhatsApp template "${config.templateName || "—"}" to ${config.to || "—"}`
+};
+
+// src/catalog/storage/file-operation/config.ts
+var FileOperationConfig = {
+  defaults: {
+    connection: "",
+    operation: "upload",
+    sourcePath: "",
+    destinationPath: "",
+    fileContent: "",
+    options: {}
+  },
+  schema: {
+    connection: { type: "connection", required: true },
+    operation: { type: "select", required: true },
+    sourcePath: { type: "string", required: false },
+    destinationPath: { type: "string", required: true },
+    fileContent: { type: "string", required: false },
+    options: { type: "json", required: false }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.connection)
+      errors.push("Storage connection is required");
+    if (!config.operation)
+      errors.push("Operation is required");
+    if (!config.destinationPath)
+      errors.push("Destination path is required");
+    if (config.operation === "upload" || config.operation === "copy" || config.operation === "move") {
+      if (!config.sourcePath) {
+        errors.push("Source path is required for upload/copy/move operations");
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...FileOperationConfig.defaults, ...userConfig };
+  },
+  getLabel: (config) => {
+    return `${config.operation.toUpperCase()}: ${config.destinationPath}`;
+  }
+};
+
+// src/catalog/transforms/format/config.ts
+var FormatConfig = {
+  defaults: { input: "", format: "json" },
+  schema: {
+    input: { type: "expression", required: true },
+    format: { type: "select", required: true }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.input)
+      errors.push("Input required");
+    if (!config.format)
+      errors.push("Format required");
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...FormatConfig.defaults, ...userConfig };
+  },
+  getLabel: (config) => `Format as ${config.format.toUpperCase()}`
+};
+
+// src/catalog/triggers/schedule-trigger/config.ts
+var ScheduleTriggerConfig = {
+  defaults: {
+    scheduleType: "interval",
+    interval: 60,
+    intervalUnit: "minutes",
+    timezone: "UTC"
+  },
+  schema: {
+    scheduleType: { type: "select", required: true },
+    interval: { type: "number", required: false, min: 1 },
+    intervalUnit: { type: "select", required: false },
+    cronExpression: { type: "string", required: false },
+    timezone: { type: "string", required: false }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.scheduleType) {
+      errors.push("Schedule type is required");
+    }
+    if (config.scheduleType === "interval") {
+      if (!config.interval || config.interval < 1) {
+        errors.push("Interval must be at least 1");
+      }
+    }
+    if (config.scheduleType === "cron" && !config.cronExpression) {
+      errors.push("Cron expression is required");
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...ScheduleTriggerConfig.defaults, ...userConfig };
+  },
+  getLabel: (config) => {
+    if (config.scheduleType === "interval") {
+      return `Every ${config.interval} ${config.intervalUnit}`;
+    }
+    return `Schedule: ${config.scheduleType}`;
+  }
+};
+
+// src/catalog/triggers/webhook-trigger/config.ts
+var WebhookTriggerConfig = {
+  defaults: {
+    method: "POST",
+    requireAuth: true
+  },
+  schema: {
+    webhookPath: { type: "string", required: false },
+    method: { type: "select", required: true },
+    requireAuth: { type: "boolean", required: false }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.method) {
+      errors.push("HTTP method is required");
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...WebhookTriggerConfig.defaults, ...userConfig };
+  },
+  getLabel: (config) => {
+    return `Webhook ${config.method}${config.webhookPath ? ` ${config.webhookPath}` : ""}`;
+  }
+};
+
+// src/catalog/utility/error/config.ts
+var ErrorConfig = {
+  defaults: {
+    message: "",
+    code: undefined
+  },
+  schema: {
+    message: { type: "string", required: true },
+    code: { type: "string", required: false }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.message)
+      errors.push("Error message is required");
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...ErrorConfig.defaults, ...userConfig };
+  },
+  getLabel: (config) => {
+    return `Error: ${config.message}`;
+  }
+};
+
+// src/rules/configContracts.ts
+var asValidator = (fn) => (config) => fn(config);
+var CONFIG_CONTRACTS = {
+  console_log: { schema: ConsoleLogConfig.schema, validate: asValidator(ConsoleLogConfig.validate) },
+  delay: { schema: DelayConfig.schema, validate: asValidator(DelayConfig.validate) },
+  http_request: { schema: HTTPRequestConfig.schema, validate: asValidator(HTTPRequestConfig.validate) },
+  graphql_query: { schema: GraphQLQueryConfig.schema, validate: asValidator(GraphQLQueryConfig.validate) },
+  email: { schema: EmailConfig.schema, validate: asValidator(EmailConfig.validate) },
+  google_chat: { schema: GoogleChatConfig.schema, validate: asValidator(GoogleChatConfig.validate) },
+  slack_message: { schema: SlackMessageConfig.schema, validate: asValidator(SlackMessageConfig.validate) },
+  teams_message: { schema: TeamsMessageConfig.schema, validate: asValidator(TeamsMessageConfig.validate) },
+  webhook_call: { schema: WebhookCallConfig.schema, validate: asValidator(WebhookCallConfig.validate) },
+  whatsapp_send: { schema: WhatsappSendConfig.schema, validate: asValidator(WhatsappSendConfig.validate) },
+  query: {
+    schema: BuildQueryContractSchema,
+    validate: (config) => {
+      const r = validateBuildQueryConfig(config);
+      const errors = (r.errors ?? []).filter((e) => e.severity !== "warning").map((e) => e.message);
+      return { valid: errors.length === 0, errors };
+    }
+  },
+  transform: { schema: TransformConfig.schema, validate: asValidator(TransformConfig.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) },
+  format: { schema: FormatConfig.schema, validate: asValidator(FormatConfig.validate) },
+  manual_trigger: { schema: ManualTriggerConfig.schema, validate: asValidator(ManualTriggerConfig.validate) },
+  schedule_trigger: { schema: ScheduleTriggerConfig.schema, validate: asValidator(ScheduleTriggerConfig.validate) },
+  webhook_trigger: { schema: WebhookTriggerConfig.schema, validate: asValidator(WebhookTriggerConfig.validate) },
+  debug: { schema: DebugConfig.schema, validate: asValidator(DebugConfig.validate) },
+  error: { schema: ErrorConfig.schema, validate: asValidator(ErrorConfig.validate) },
+  variables: { schema: VariablesConfig.schema, validate: asValidator(VariablesConfig.validate) }
+};
+function contractFor(actionId) {
+  return actionId ? CONFIG_CONTRACTS[actionId] : undefined;
+}
+function declaredKeys(actionId) {
+  const c = contractFor(actionId);
+  if (!c)
+    return [];
+  return Object.entries(c.schema).filter(([, f]) => f.type !== "none").map(([k]) => k);
+}
+function isEditorPrivateKey(key) {
+  return key.startsWith("_");
+}
+var CONTRACT_TYPE_TO_FIELD_TYPE = {
+  string: "string" /* String */,
+  text: "string" /* String */,
+  select: "select" /* Select */,
+  json: "json" /* JSON */,
+  connection: "connection" /* Connection */,
+  number: "number" /* Number */,
+  boolean: "boolean" /* Boolean */,
+  array: "array" /* Array */,
+  object: "object" /* Object */,
+  url: "url" /* URL */,
+  expression: "expression" /* Expression */,
+  code: "code" /* Code */
+};
+function humanise(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/^\w/, (c) => c.toUpperCase());
+}
+function contractFieldsFor(definition) {
+  const declared = definition.inputSchema?.fields ?? [];
+  const contract = contractFor(definition.id);
+  if (!contract)
+    return declared;
+  const seen = new Set(declared.map((f) => f.key));
+  const derived = [];
+  for (const [key, field] of Object.entries(contract.schema)) {
+    if (seen.has(key) || field.type === "none")
+      continue;
+    derived.push({
+      key,
+      label: humanise(key),
+      type: CONTRACT_TYPE_TO_FIELD_TYPE[field.type] ?? "string" /* String */,
+      validation: { required: field.required === true },
+      ...field.options ? { options: field.options.map((v) => ({ label: String(v), value: v })) } : {}
+    });
+  }
+  return [...declared, ...derived];
+}
+function contractDrift(definition) {
+  const contract = contractFor(definition.id);
+  if (!contract)
+    return [];
+  const covers = (key) => {
+    if (key in contract.schema)
+      return true;
+    const root = key.split(".")[0];
+    const rootField = contract.schema[root];
+    return !!rootField && (rootField.type === "object" || rootField.type === "json");
+  };
+  return (definition.inputSchema?.fields ?? []).map((f) => f.key).filter((k) => !covers(k));
+}
+function contractVocabularyDrift(actionId) {
+  const c = contractFor(actionId);
+  if (!c)
+    return [];
+  const known = new Set([...Object.keys(CONTRACT_TYPE_TO_FIELD_TYPE), "none"]);
+  return Object.entries(c.schema).filter(([, f]) => !known.has(f.type)).map(([k, f]) => `${k}:${f.type}`);
+}
+function contractDerivedKeys(definition) {
+  const own = new Set((definition.inputSchema?.fields ?? []).map((f) => f.key));
+  return new Set(contractFieldsFor(definition).map((f) => f.key).filter((k) => !own.has(k)));
+}
+
 // src/rules/configSafety.ts
 var MAX_STEP_CONFIG_BYTES = 256 * 1024;
 var FORBIDDEN_KEYS = new Set(["__proto__", "constructor", "prototype"]);
@@ -4210,7 +5045,8 @@ function validateStepConfig(step) {
   const definition = typeof step.actionDefinitionId === "string" ? getActionById(step.actionDefinitionId) : undefined;
   if (!definition)
     return issues;
-  const declared = new Map(definition.inputSchema.fields.map((f) => [f.key, f]));
+  const declared = new Map(contractFieldsFor(definition).map((f) => [f.key, f]));
+  const derived = contractDerivedKeys(definition);
   const entries = Object.entries(config);
   for (const [key, value] of entries) {
     const field = declared.get(key);
@@ -4226,7 +5062,7 @@ function validateStepConfig(step) {
     }
     if (!typeMatches(field, value)) {
       issues.push({
-        severity: "error",
+        severity: derived.has(key) ? "warning" : "error",
         code: "FIELD_WRONG_TYPE",
         stepId,
         field: key,