@doclo/core 0.1.5

package/dist/internal/validation-utils.d.ts

@@ -0,0 +1 @@
+export { z as AggregatedMetrics, B as BBox, r as CategorizeNodeConfig, s as ChunkMetadata, u as ChunkNodeConfig, t as ChunkOutput, n as CitationConfig, k as CitationSourceType, v as CombineNodeConfig, T as CompatibilityRule, C as ConsensusConfig, e as ConsensusMetadata, d as ConsensusRunResult, D as DocumentIR, b as DocumentIRExtras, x as EnhancedExtractionSchema, E as ExtractNodeConfig, $ as ExtractedImage, m as FieldCitation, F as FieldVotingDetails, G as FlowContext, a6 as FlowExecutionError, h as FlowInput, i as FlowInputValidation, j as FlowResult, a7 as FlowValidationError, I as IRLine, a as IRPage, W as JSONSchemaNode, c as LLMJsonProvider, L as LLMProvider, Z as LanguageOptions, l as LineCitation, g as MaybeWithConsensusMetadata, M as MultimodalInput, a8 as NODE_COMPATIBILITY_MATRIX, H as NodeCtx, K as NodeDef, aq as NodeObservabilityContext, J as NodeTypeInfo, Q as NodeTypeName, N as NormalizedBBox, O as OCRProvider, a0 as OCRProviderOptions, w as OutputNodeConfig, o as OutputWithCitations, f as OutputWithConsensus, Y as PageRangeOptions, p as ParseNodeConfig, X as ProcessingMode, a2 as ProviderCitation, ah as RESERVED_VARIABLES, R as ReasoningConfig, _ as SegmentationResult, S as SplitDocument, q as SplitNodeConfig, y as StepMetric, ao as SupportedMimeType, ap as TraceContextLite, V as VLMProvider, a1 as VLMProviderOptions, U as ValidationResult, a3 as aggregateMetrics, af as canStartForEachItemFlow, ab as getCompatibleTargets, aa as getNodeTypeInfo, a9 as getNodeTypeName, ac as getSuggestedConnections, ae as getValidForEachStarters, a4 as node, ai as protectReservedVariables, a5 as runPipeline, ag as validateJson, ad as validateNodeConnection } from '../validation-CzOz6fwq.js';

package/dist/internal/validation-utils.js

@@ -0,0 +1,650 @@
+// src/internal/validation-utils.ts
+function aggregateMetrics(metrics) {
+  const byProvider = {};
+  const result = metrics.reduce((acc, m) => {
+    acc.totalDurationMs += m.ms;
+    acc.totalCostUSD += m.costUSD || 0;
+    acc.totalInputTokens += m.inputTokens || 0;
+    acc.totalOutputTokens += m.outputTokens || 0;
+    acc.totalCacheCreationTokens += m.cacheCreationInputTokens || 0;
+    acc.totalCacheReadTokens += m.cacheReadInputTokens || 0;
+    if (m.provider) {
+      if (!byProvider[m.provider]) {
+        byProvider[m.provider] = { costUSD: 0, inputTokens: 0, outputTokens: 0, callCount: 0 };
+      }
+      byProvider[m.provider].costUSD += m.costUSD || 0;
+      byProvider[m.provider].inputTokens += m.inputTokens || 0;
+      byProvider[m.provider].outputTokens += m.outputTokens || 0;
+      byProvider[m.provider].callCount += 1;
+    }
+    return acc;
+  }, {
+    totalDurationMs: 0,
+    totalCostUSD: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCacheCreationTokens: 0,
+    totalCacheReadTokens: 0,
+    stepCount: metrics.length,
+    byProvider
+  });
+  return result;
+}
+var node = (key, run) => ({ key, run });
+async function runPipeline(steps, input, observabilityContext) {
+  const artifacts = {};
+  const metrics = [];
+  const ctx = {
+    stepId: observabilityContext?.stepId,
+    artifacts,
+    emit: (k, v) => {
+      artifacts[k] = v;
+    },
+    metrics: { push: (m) => metrics.push(m) },
+    observability: observabilityContext
+  };
+  let acc = input;
+  for (const s of steps) {
+    acc = await s.run(acc, ctx);
+    ctx.emit(s.key, acc);
+  }
+  return { output: acc, artifacts, metrics };
+}
+var FlowExecutionError = class _FlowExecutionError extends Error {
+  constructor(message, failedStep, failedStepIndex, failedStepType, completedSteps, originalError, partialArtifacts) {
+    super(message);
+    this.failedStep = failedStep;
+    this.failedStepIndex = failedStepIndex;
+    this.failedStepType = failedStepType;
+    this.completedSteps = completedSteps;
+    this.originalError = originalError;
+    this.partialArtifacts = partialArtifacts;
+    this.name = "FlowExecutionError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _FlowExecutionError);
+    }
+  }
+};
+var FlowValidationError = class _FlowValidationError extends Error {
+  constructor(message, reason, suggestions, sourceNode, targetNode, sourceOutputType, targetInputTypes) {
+    super(message);
+    this.reason = reason;
+    this.suggestions = suggestions;
+    this.sourceNode = sourceNode;
+    this.targetNode = targetNode;
+    this.sourceOutputType = sourceOutputType;
+    this.targetInputTypes = targetInputTypes;
+    this.name = "FlowValidationError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _FlowValidationError);
+    }
+  }
+};
+var NODE_COMPATIBILITY_MATRIX = {
+  parse: {
+    parse: {
+      valid: false,
+      reason: "Cannot chain parse nodes. Parse is typically the starting node."
+    },
+    split: {
+      valid: false,
+      reason: "Split requires FlowInput, but parse outputs DocumentIR. Use split directly on input instead.",
+      note: "If you need to re-split after parsing, use trigger to invoke a child flow with FlowInput."
+    },
+    categorize: {
+      valid: true,
+      note: "categorize accepts DocumentIR and wraps it with {input, category}"
+    },
+    extract: {
+      valid: true,
+      note: "extract accepts DocumentIR and produces typed JSON"
+    },
+    chunk: {
+      valid: true,
+      note: "chunk accepts DocumentIR and produces ChunkOutput for RAG"
+    },
+    combine: {
+      valid: false,
+      reason: "Parse outputs DocumentIR (single document), not an array. Combine requires array input from forEach.",
+      note: "Use parse with chunked:true to output DocumentIR[], then use combine."
+    },
+    trigger: {
+      valid: true,
+      note: "trigger accepts any input type"
+    },
+    output: {
+      valid: true,
+      note: "output node can follow any node to select or transform results"
+    }
+  },
+  split: {
+    parse: {
+      valid: true,
+      requiresForEach: true,
+      reason: "Split outputs SplitDocument[] which requires forEach. forEach auto-unwraps SplitDocument.input \u2192 FlowInput for parse.",
+      note: "Enable forEach on split node before connecting to parse."
+    },
+    split: {
+      valid: false,
+      reason: "Cannot nest split operations. Split nodes cannot appear in forEach itemFlow."
+    },
+    categorize: {
+      valid: true,
+      requiresForEach: true,
+      reason: "Split outputs SplitDocument[] which requires forEach. forEach auto-unwraps SplitDocument.input for categorize."
+    },
+    extract: {
+      valid: true,
+      requiresForEach: true,
+      reason: "Split outputs SplitDocument[] which requires forEach. forEach auto-unwraps SplitDocument.input for extract."
+    },
+    chunk: {
+      valid: false,
+      reason: "SplitDocument output is incompatible with Chunk input. Chunk expects DocumentIR or DocumentIR[].",
+      note: "Use parse in forEach after split to convert SplitDocument \u2192 DocumentIR, then chunk."
+    },
+    combine: {
+      valid: false,
+      reason: "Combine should appear AFTER forEach completes, not as a forEach itemFlow step.",
+      note: "Place combine after the forEach block to merge results."
+    },
+    trigger: {
+      valid: true,
+      requiresForEach: true,
+      reason: "Split outputs SplitDocument[] which requires forEach for processing.",
+      note: "forEach auto-unwraps SplitDocument.input for child flow."
+    },
+    output: {
+      valid: true,
+      note: "output node can follow any node to select or transform results"
+    }
+  },
+  categorize: {
+    parse: {
+      valid: true,
+      note: "categorize outputs {input, category}. Conditional can unwrap this or use directly."
+    },
+    split: {
+      valid: false,
+      reason: "Split requires FlowInput, but categorize outputs {input, category}.",
+      note: "Use conditional to unwrap and pass input field to split."
+    },
+    categorize: {
+      valid: true,
+      note: "Can chain categorize nodes for multi-level classification."
+    },
+    extract: {
+      valid: true,
+      note: "extract can process the categorized document."
+    },
+    chunk: {
+      valid: false,
+      reason: "Categorize wraps input as {input, category}. Chunk needs unwrapped DocumentIR.",
+      note: "Use conditional to unwrap input field before chunk."
+    },
+    combine: {
+      valid: false,
+      reason: "Categorize outputs single result {input, category}, not an array. Combine requires array input."
+    },
+    trigger: {
+      valid: true,
+      note: "trigger accepts any input type, including {input, category}"
+    },
+    output: {
+      valid: true,
+      note: "output node can follow any node to select or transform results"
+    }
+  },
+  extract: {
+    parse: {
+      valid: false,
+      reason: "Extract outputs typed JSON (terminal node). Cannot pipe JSON to parse.",
+      note: "Extract should be one of the last steps in a flow. Use combine if extracting in parallel."
+    },
+    split: {
+      valid: false,
+      reason: "Extract outputs typed JSON (terminal node). Cannot pipe JSON to split."
+    },
+    categorize: {
+      valid: false,
+      reason: "Extract outputs typed JSON (terminal node). Cannot pipe JSON to categorize."
+    },
+    extract: {
+      valid: false,
+      reason: "Extract outputs typed JSON (terminal node). Cannot chain extractions on JSON output.",
+      note: "If you need multi-step extraction, extract from DocumentIR/ChunkOutput in parallel, then combine."
+    },
+    chunk: {
+      valid: false,
+      reason: "Extract outputs typed JSON, not DocumentIR. Chunk expects DocumentIR input."
+    },
+    combine: {
+      valid: true,
+      note: "Use combine to merge parallel extraction results from forEach."
+    },
+    trigger: {
+      valid: true,
+      note: "trigger accepts any input type, including extracted JSON"
+    },
+    output: {
+      valid: true,
+      note: "output node can follow any node to select or transform results"
+    }
+  },
+  chunk: {
+    parse: {
+      valid: false,
+      reason: "Chunk outputs ChunkOutput (specialized type), not FlowInput. Parse expects FlowInput as input."
+    },
+    split: {
+      valid: false,
+      reason: "Chunk outputs ChunkOutput, incompatible with Split input (FlowInput)."
+    },
+    categorize: {
+      valid: false,
+      reason: "Chunk outputs ChunkOutput, incompatible with Categorize input (DocumentIR|FlowInput).",
+      note: "Categorize before chunking, not after."
+    },
+    extract: {
+      valid: true,
+      note: "extract has special handling for ChunkOutput - extracts data from chunks."
+    },
+    chunk: {
+      valid: false,
+      reason: "Cannot chain chunk operations. Chunk only once per document.",
+      note: "Different chunking strategies should be applied to the original DocumentIR, not to chunks."
+    },
+    combine: {
+      valid: false,
+      reason: "Chunk outputs ChunkOutput (specialized type), not an array type. Combine expects T[].",
+      note: "Use chunk on individual documents in forEach, then extract, then combine extractions."
+    },
+    trigger: {
+      valid: true,
+      note: "trigger accepts any input type, including ChunkOutput"
+    },
+    output: {
+      valid: true,
+      note: "output node can follow any node to select or transform results"
+    }
+  },
+  combine: {
+    parse: {
+      valid: true,
+      note: "After combining, result can be re-parsed if needed."
+    },
+    split: {
+      valid: false,
+      reason: "Combine output depends on strategy. Split requires FlowInput.",
+      note: "Most combine strategies output merged objects/arrays, not FlowInput."
+    },
+    categorize: {
+      valid: true,
+      note: "Can categorize combined results."
+    },
+    extract: {
+      valid: true,
+      note: "Can extract from combined results."
+    },
+    chunk: {
+      valid: true,
+      note: "Can chunk combined DocumentIR. Only valid if combine output is DocumentIR or DocumentIR[]."
+    },
+    combine: {
+      valid: false,
+      reason: "Cannot chain combine nodes. Combine once per forEach operation."
+    },
+    trigger: {
+      valid: true,
+      note: "trigger accepts any input type"
+    },
+    output: {
+      valid: true,
+      note: "output node can follow any node to select or transform results"
+    }
+  },
+  trigger: {
+    parse: {
+      valid: true,
+      requiresRuntimeValidation: true,
+      note: "Valid only if child flow returns FlowInput. Type safety cannot be guaranteed at build-time."
+    },
+    split: {
+      valid: true,
+      requiresRuntimeValidation: true,
+      note: "Valid only if child flow returns FlowInput. Type safety cannot be guaranteed at build-time."
+    },
+    categorize: {
+      valid: true,
+      requiresRuntimeValidation: true,
+      note: "Valid only if child flow returns DocumentIR or FlowInput. Type safety cannot be guaranteed at build-time."
+    },
+    extract: {
+      valid: true,
+      requiresRuntimeValidation: true,
+      note: "Valid only if child flow returns DocumentIR, FlowInput, or ChunkOutput. Type safety cannot be guaranteed at build-time."
+    },
+    chunk: {
+      valid: true,
+      requiresRuntimeValidation: true,
+      note: "Valid only if child flow returns DocumentIR or DocumentIR[]. Type safety cannot be guaranteed at build-time."
+    },
+    combine: {
+      valid: true,
+      requiresRuntimeValidation: true,
+      note: "Valid only if child flow returns an array (T[]). Type safety cannot be guaranteed at build-time."
+    },
+    trigger: {
+      valid: true,
+      requiresRuntimeValidation: true,
+      note: "Can nest trigger nodes (with circular dependency detection and max depth limits). Output type depends on nested child flow."
+    },
+    output: {
+      valid: true,
+      note: "output node can follow any node to select or transform results"
+    }
+  },
+  output: {
+    parse: {
+      valid: false,
+      reason: "Output is a terminal node that selects/transforms results. Cannot chain to other nodes."
+    },
+    split: {
+      valid: false,
+      reason: "Output is a terminal node that selects/transforms results. Cannot chain to other nodes."
+    },
+    categorize: {
+      valid: false,
+      reason: "Output is a terminal node that selects/transforms results. Cannot chain to other nodes."
+    },
+    extract: {
+      valid: false,
+      reason: "Output is a terminal node that selects/transforms results. Cannot chain to other nodes."
+    },
+    chunk: {
+      valid: false,
+      reason: "Output is a terminal node that selects/transforms results. Cannot chain to other nodes."
+    },
+    combine: {
+      valid: false,
+      reason: "Output is a terminal node that selects/transforms results. Cannot chain to other nodes."
+    },
+    trigger: {
+      valid: false,
+      reason: "Output is a terminal node that selects/transforms results. Cannot chain to other nodes."
+    },
+    output: {
+      valid: true,
+      note: "Multiple output nodes are allowed to create multiple named outputs from a flow."
+    }
+  }
+};
+function getNodeTypeName(node2) {
+  if (!node2 || !node2.key) return null;
+  const key = node2.key;
+  const knownTypes = ["parse", "split", "categorize", "extract", "chunk", "combine", "trigger", "output"];
+  return knownTypes.includes(key) ? key : null;
+}
+function getNodeTypeInfo(node2) {
+  return node2.__meta || null;
+}
+function getCompatibleTargets(sourceType, includeForEach = false) {
+  const rules = NODE_COMPATIBILITY_MATRIX[sourceType];
+  if (!rules) return [];
+  return Object.entries(rules).filter(([_, rule]) => {
+    if (!rule.valid) return false;
+    if (rule.requiresForEach && !includeForEach) return false;
+    return true;
+  }).map(([targetType, _]) => targetType);
+}
+function getSuggestedConnections(sourceType) {
+  const compatibleTargets = getCompatibleTargets(sourceType, false);
+  const forEachTargets = getCompatibleTargets(sourceType, true).filter(
+    (t) => !compatibleTargets.includes(t)
+  );
+  if (compatibleTargets.length === 0 && forEachTargets.length === 0) {
+    return [`${sourceType} has no standard outgoing connections (terminal node).`];
+  }
+  const suggestions = [];
+  if (compatibleTargets.length > 0) {
+    suggestions.push(`${sourceType} can connect to:`);
+    compatibleTargets.forEach((target) => {
+      const rule = NODE_COMPATIBILITY_MATRIX[sourceType][target];
+      suggestions.push(`  \u2022 ${target}${rule.note ? ` - ${rule.note}` : ""}`);
+    });
+  }
+  if (forEachTargets.length > 0) {
+    suggestions.push(`${sourceType} can connect to (with forEach enabled):`);
+    forEachTargets.forEach((target) => {
+      const rule = NODE_COMPATIBILITY_MATRIX[sourceType][target];
+      suggestions.push(`  \u2022 ${target}${rule.note ? ` - ${rule.note}` : ""}`);
+    });
+  }
+  return suggestions;
+}
+function validateNodeConnection(sourceType, targetType, forEachEnabled = false) {
+  const rule = NODE_COMPATIBILITY_MATRIX[sourceType]?.[targetType];
+  if (!rule) {
+    return {
+      valid: false,
+      reason: `Unknown node type combination: ${sourceType} \u2192 ${targetType}`,
+      suggestions: ["Ensure both nodes are valid node types."]
+    };
+  }
+  if (!rule.valid) {
+    return {
+      valid: false,
+      reason: rule.reason,
+      suggestions: getSuggestedConnections(sourceType)
+    };
+  }
+  if (rule.requiresForEach && !forEachEnabled) {
+    return {
+      valid: false,
+      reason: `Cannot connect ${sourceType} to ${targetType} without forEach enabled.`,
+      suggestions: [
+        `Enable forEach on the ${sourceType} node:`,
+        `  1. Click the ${sourceType} node`,
+        `  2. Enable "forEach Processing" in the configuration`,
+        `  3. Try connecting again`,
+        "",
+        ...getSuggestedConnections(sourceType)
+      ],
+      requiresForEach: true
+    };
+  }
+  if (rule.requiresRuntimeValidation) {
+    return {
+      valid: true,
+      warning: `\u26A0\uFE0F  ${sourceType} \u2192 ${targetType}: ${rule.note || "Type compatibility depends on runtime values and cannot be validated at build-time."}`
+    };
+  }
+  return {
+    valid: true
+  };
+}
+function getValidForEachStarters(parentType) {
+  const rules = NODE_COMPATIBILITY_MATRIX[parentType];
+  if (!rules) return [];
+  return Object.entries(rules).filter(([_, rule]) => rule.valid && rule.requiresForEach).map(([targetType, _]) => targetType);
+}
+function canStartForEachItemFlow(parentType, starterType) {
+  const rule = NODE_COMPATIBILITY_MATRIX[parentType]?.[starterType];
+  if (!rule) {
+    return {
+      valid: false,
+      reason: `Unknown node type combination: ${parentType} \u2192 forEach \u2192 ${starterType}`,
+      suggestions: ["Ensure both nodes are valid node types."]
+    };
+  }
+  if (rule.valid && rule.requiresForEach) {
+    return {
+      valid: true
+    };
+  }
+  if (!rule.valid) {
+    const validStarters2 = getValidForEachStarters(parentType);
+    return {
+      valid: false,
+      reason: `${starterType} cannot start forEach itemFlow after ${parentType}. ${rule.reason || "Type incompatible with forEach unwrapped item."}`,
+      suggestions: validStarters2.length > 0 ? [`Valid itemFlow starters for ${parentType}: ${validStarters2.join(", ")}`] : [`${parentType} has no valid forEach itemFlow starters.`]
+    };
+  }
+  const validStarters = getValidForEachStarters(parentType);
+  return {
+    valid: false,
+    reason: `${starterType} cannot start forEach itemFlow after ${parentType}. This connection does not require forEach, meaning it expects the full array, not individual items.`,
+    suggestions: validStarters.length > 0 ? [`Valid itemFlow starters for ${parentType}: ${validStarters.join(", ")}`] : [`${parentType} has no valid forEach itemFlow starters.`]
+  };
+}
+function validateJson(data, schema) {
+  const errors = [];
+  const MAX_DEPTH = 50;
+  function validate(value, schema2, path = "", depth = 0) {
+    if (depth > MAX_DEPTH) {
+      errors.push(`${path || "root"}: maximum nesting depth (${MAX_DEPTH}) exceeded`);
+      return;
+    }
+    if (schema2.nullable && (value === null || value === void 0)) {
+      return;
+    }
+    if (value === null || value === void 0) {
+      if (schema2.nullable !== true) {
+        errors.push(`${path || "root"}: value is null or undefined`);
+      }
+      return;
+    }
+    const actualType = Array.isArray(value) ? "array" : typeof value;
+    const expectedType = schema2.type;
+    if (expectedType) {
+      if (expectedType === "integer") {
+        if (typeof value !== "number" || !Number.isInteger(value)) {
+          errors.push(`${path || "root"}: expected integer, got ${actualType}`);
+          return;
+        }
+      } else if (expectedType === "number") {
+        if (typeof value !== "number") {
+          errors.push(`${path || "root"}: expected number, got ${actualType}`);
+          return;
+        }
+      } else if (expectedType === "string") {
+        if (typeof value !== "string") {
+          errors.push(`${path || "root"}: expected string, got ${actualType}`);
+          return;
+        }
+      } else if (expectedType === "boolean") {
+        if (typeof value !== "boolean") {
+          errors.push(`${path || "root"}: expected boolean, got ${actualType}`);
+          return;
+        }
+      } else if (expectedType === "object") {
+        if (typeof value !== "object" || Array.isArray(value)) {
+          errors.push(`${path || "root"}: expected object, got ${actualType}`);
+          return;
+        }
+        if (schema2.required && Array.isArray(schema2.required)) {
+          for (const reqProp of schema2.required) {
+            if (!(reqProp in value)) {
+              errors.push(`${path}.${reqProp}: required property missing`);
+            }
+          }
+        }
+        const dangerousProps = ["__proto__", "constructor", "prototype"];
+        if (schema2.additionalProperties === false && schema2.properties) {
+          const allowedProps = Object.keys(schema2.properties);
+          const requiredProps = schema2.required || [];
+          const allAllowedProps = /* @__PURE__ */ new Set([...allowedProps, ...requiredProps]);
+          for (const key of [...Object.keys(value), ...Object.getOwnPropertyNames(value)]) {
+            if (dangerousProps.includes(key)) {
+              errors.push(`${path}.${key}: dangerous property not allowed`);
+              continue;
+            }
+            if (!allAllowedProps.has(key)) {
+              errors.push(`${path}.${key}: additional property not allowed`);
+            }
+          }
+        } else {
+          for (const key of dangerousProps) {
+            if (key in value && Object.prototype.hasOwnProperty.call(value, key)) {
+              errors.push(`${path}.${key}: dangerous property not allowed`);
+            }
+          }
+        }
+        if (schema2.properties) {
+          const valueObj = value;
+          for (const [propName, propSchema] of Object.entries(schema2.properties)) {
+            if (propName in valueObj) {
+              validate(valueObj[propName], propSchema, path ? `${path}.${propName}` : propName, depth + 1);
+            }
+          }
+        }
+      } else if (expectedType === "array") {
+        if (!Array.isArray(value)) {
+          errors.push(`${path || "root"}: expected array, got ${actualType}`);
+          return;
+        }
+        if (schema2.items && !Array.isArray(schema2.items)) {
+          const itemSchema = schema2.items;
+          value.forEach((item, index) => {
+            validate(item, itemSchema, `${path}[${index}]`, depth + 1);
+          });
+        }
+      }
+    }
+  }
+  validate(data, schema);
+  if (errors.length > 0) {
+    throw new Error(`Schema validation failed:
+${errors.join("\n")}`);
+  }
+  return data;
+}
+var RESERVED_VARIABLES = {
+  extract: ["schema", "documentText", "schemaTitle", "schemaDescription", "structuredFormat"],
+  categorize: ["categories", "documentText"],
+  parse: ["format", "schema", "describeFigures", "citationsEnabled"]
+};
+function protectReservedVariables(nodeType, userVariables, autoInjectedVariables) {
+  if (!userVariables || Object.keys(userVariables).length === 0) {
+    return autoInjectedVariables;
+  }
+  const reserved = RESERVED_VARIABLES[nodeType];
+  const warnings = [];
+  for (const key of reserved) {
+    if (key in userVariables) {
+      warnings.push(key);
+    }
+  }
+  if (warnings.length > 0) {
+    console.warn(
+      `[doclo] Attempted to override reserved variables in ${nodeType} node: ${warnings.join(", ")}. These variables are auto-injected from config and cannot be overridden. They will be ignored.`
+    );
+  }
+  return {
+    ...autoInjectedVariables,
+    ...userVariables,
+    // Restore reserved variables to ensure they can't be overridden
+    ...Object.fromEntries(
+      reserved.map((key) => [key, autoInjectedVariables[key]])
+    )
+  };
+}
+export {
+  FlowExecutionError,
+  FlowValidationError,
+  NODE_COMPATIBILITY_MATRIX,
+  RESERVED_VARIABLES,
+  aggregateMetrics,
+  canStartForEachItemFlow,
+  getCompatibleTargets,
+  getNodeTypeInfo,
+  getNodeTypeName,
+  getSuggestedConnections,
+  getValidForEachStarters,
+  node,
+  protectReservedVariables,
+  runPipeline,
+  validateJson,
+  validateNodeConnection
+};
+//# sourceMappingURL=validation-utils.js.map