@open-mercato/core 0.7.1-develop.7193.1.910a5b0a1e → 0.7.1-develop.7194.1.ab4fc81f82

package/src/modules/workflows/lib/dry-run.ts

@@ -0,0 +1,203 @@
+/**
+ * Workflows Module — Dry-run (spec section 8.2)
+ *
+ * A dry run is a REAL instance (`WorkflowInstance.isDryRun`) executed by the
+ * ordinary engine loop with every effector replaced by its registry `mock`.
+ * There is deliberately no second simulation path: a parallel interpreter would
+ * drift from the engine and the report would stop being evidence about the
+ * workflow that actually runs.
+ *
+ * This module is PURE — no ORM, no DI, no React — so the isolation rules and
+ * the "Would do" report are unit-testable without a database.
+ */
+
+import type { WorkflowValidationIssueSeverity } from './collect-validation-issues'
+
+/**
+ * The subset of `WorkflowInstance` every isolation decision reads. Taking the
+ * shape rather than the entity keeps this module free of the ORM import and
+ * lets the engine pass a branch-scoped view where it has one.
+ */
+export type DryRunAwareInstance = {
+  isDryRun?: boolean | null
+}
+
+export function isDryRunInstance(instance: DryRunAwareInstance | null | undefined): boolean {
+  return instance?.isDryRun === true
+}
+
+/**
+ * Raised when a dry run reaches an activity type that refuses simulation
+ * (`mock: 'refuse'`) or declares no mock at all.
+ *
+ * Spec section 8.2: *"`mock: 'refuse'` types stop the dry-run at that node with
+ * an explicit marker."* A refusal is NOT an activity failure — nothing was
+ * attempted — so it must never be routed down the step's error route or
+ * absorbed by its `errorDirective`. `isDryRunRefusal` is what the failure paths
+ * check to keep that promise, and it is structural (a marker property) for the
+ * same reason `isRetryableError` is: the check must survive an error crossing a
+ * module boundary.
+ */
+export class WorkflowDryRunRefusalError extends Error {
+  readonly dryRunRefused = true
+
+  constructor(
+    readonly activityType: string,
+    readonly reason: DryRunRefusalReason,
+    readonly activityName?: string,
+  ) {
+    super(`[internal] dry run cannot simulate activity type ${activityType} (${reason})`)
+    this.name = 'WorkflowDryRunRefusalError'
+  }
+}
+
+export type DryRunRefusalReason = 'refused' | 'noMock'
+
+export function isDryRunRefusal(error: unknown): error is WorkflowDryRunRefusalError {
+  if (!error || typeof error !== 'object') return false
+  return (error as { dryRunRefused?: unknown }).dryRunRefused === true
+}
+
+// ============================================================================
+// "Would do" report
+// ============================================================================
+
+/**
+ * Event types a dry run writes in addition to the ordinary run log. They ride
+ * the same `WorkflowEvent` table because the module's event-sourcing rule
+ * already makes that the audit trail, and because the report then inherits the
+ * run views' ordering, scoping and retention for free.
+ */
+export const DRY_RUN_EVENT_TYPES = {
+  started: 'DRY_RUN_STARTED',
+  activitySimulated: 'ACTIVITY_SIMULATED',
+  activityRefused: 'ACTIVITY_SIMULATION_REFUSED',
+  userTaskSimulated: 'USER_TASK_SIMULATED',
+  businessRuleActionsSuppressed: 'BUSINESS_RULE_ACTIONS_SUPPRESSED',
+} as const
+
+export type DryRunEventType = typeof DRY_RUN_EVENT_TYPES[keyof typeof DRY_RUN_EVENT_TYPES]
+
+export type WouldDoEntryKind =
+  | 'activity'
+  | 'refusal'
+  | 'userTask'
+  | 'businessRule'
+
+export type WouldDoEntry = {
+  id: string
+  kind: WouldDoEntryKind
+  /** `error` marks the refusal that stopped the run; everything else is informational. */
+  severity: WorkflowValidationIssueSeverity | 'info'
+  stepId: string | null
+  occurredAt: string
+  /** Machine label — `SEND_EMAIL`, `INVOKE_AGENT`, `USER_TASK`, a rule id. */
+  subject: string
+  detail: Record<string, unknown>
+}
+
+export type WouldDoSourceEvent = {
+  id: string
+  eventType: string
+  stepId?: string | null
+  occurredAt: string | Date
+  eventData?: Record<string, unknown> | null
+}
+
+export type WouldDoReport = {
+  entries: WouldDoEntry[]
+  /** True once a refusal stopped the run — the report is then not the whole graph. */
+  stoppedByRefusal: boolean
+}
+
+const asRecord = (value: unknown): Record<string, unknown> =>
+  typeof value === 'object' && value !== null ? (value as Record<string, unknown>) : {}
+
+const asText = (value: unknown, fallback: string): string =>
+  typeof value === 'string' && value.length > 0 ? value : fallback
+
+function toIsoString(value: string | Date): string {
+  return value instanceof Date ? value.toISOString() : value
+}
+
+function describeEvent(event: WouldDoSourceEvent): Omit<WouldDoEntry, 'id' | 'stepId' | 'occurredAt'> | null {
+  const data = asRecord(event.eventData)
+  switch (event.eventType) {
+    case DRY_RUN_EVENT_TYPES.activitySimulated:
+      return {
+        kind: 'activity',
+        severity: 'info',
+        subject: asText(data.activityType, 'ACTIVITY'),
+        detail: {
+          activityName: data.activityName ?? null,
+          output: data.output ?? null,
+        },
+      }
+    case DRY_RUN_EVENT_TYPES.activityRefused:
+      return {
+        kind: 'refusal',
+        severity: 'error',
+        subject: asText(data.activityType, 'ACTIVITY'),
+        detail: { reason: asText(data.reason, 'noMock') },
+      }
+    case DRY_RUN_EVENT_TYPES.userTaskSimulated:
+      return {
+        kind: 'userTask',
+        severity: 'warning',
+        subject: asText(data.taskName, 'USER_TASK'),
+        detail: {
+          assignedTo: data.assignedTo ?? null,
+          assignedToRoles: data.assignedToRoles ?? null,
+          decisions: data.decisions ?? [],
+        },
+      }
+    case DRY_RUN_EVENT_TYPES.businessRuleActionsSuppressed:
+      return {
+        kind: 'businessRule',
+        severity: 'warning',
+        subject: asText(data.ruleId, 'BUSINESS_RULE'),
+        detail: { phase: asText(data.phase, 'pre_transition') },
+      }
+    default:
+      return null
+  }
+}
+
+/**
+ * Build the ordered "Would do" report from a run's events.
+ *
+ * Callers pass events in ANY order; the report sorts by `occurredAt` and falls
+ * back to the caller's order for ties (an activity and its refusal can share a
+ * millisecond), which is why the sort is explicit and stable rather than a bare
+ * `.sort()`.
+ */
+export function buildWouldDoReport(events: WouldDoSourceEvent[]): WouldDoReport {
+  const decorated: Array<{ entry: WouldDoEntry; index: number }> = []
+
+  events.forEach((event, index) => {
+    const described = describeEvent(event)
+    if (!described) return
+    decorated.push({
+      index,
+      entry: {
+        ...described,
+        id: event.id,
+        stepId: event.stepId ?? null,
+        occurredAt: toIsoString(event.occurredAt),
+      },
+    })
+  })
+
+  decorated.sort((left, right) => {
+    if (left.entry.occurredAt !== right.entry.occurredAt) {
+      return left.entry.occurredAt < right.entry.occurredAt ? -1 : 1
+    }
+    return left.index - right.index
+  })
+
+  const entries = decorated.map((item) => item.entry)
+  return {
+    entries,
+    stoppedByRefusal: entries.some((entry) => entry.kind === 'refusal'),
+  }
+}

package/src/modules/workflows/lib/duration.ts

@@ -1,55 +1,169 @@
+export type Iso8601DurationParts = {
+  years: number
+  months: number
+  weeks: number
+  days: number
+  hours: number
+  minutes: number
+  seconds: number
+}
+
+/**
+ * Full ISO 8601 duration grammar: `P[nY][nM][nW][nD][T[nH][nM][nS]]`.
+ *
+ * The lookaheads reject the designator-only forms `P`, `PT` and `P1DT`, and the
+ * anchors reject anything with trailing junk. `M` before `T` is months, `M`
+ * after it is minutes — the distinction the hand-rolled parsers this replaces
+ * could not make.
+ */
+const ISO_8601_DURATION_PATTERN =
+  /^P(?=\d|T\d)(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?(?:T(?=\d)(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/
+
+const SIMPLE_DURATION_PATTERN = /^(\d+)(d|h|m|s)$/
+
+const MS_PER_SECOND = 1000
+const MS_PER_MINUTE = 60 * MS_PER_SECOND
+const MS_PER_HOUR = 60 * MS_PER_MINUTE
+const MS_PER_DAY = 24 * MS_PER_HOUR
+
+/**
+ * Parse an ISO 8601 duration into its calendar components.
+ *
+ * Pure and total: returns `null` for anything that is not a valid ISO 8601
+ * duration, so callers decide how to surface the problem.
+ *
+ * @param duration - Duration string (e.g. "PT30M", "P1W", "P1DT12H")
+ * @returns Parsed components, or `null` when the string is not ISO 8601
+ */
+export function parseIso8601Duration(duration: string): Iso8601DurationParts | null {
+  const match = duration.match(ISO_8601_DURATION_PATTERN)
+  if (!match) return null
+
+  return {
+    years: parseInt(match[1] || '0', 10),
+    months: parseInt(match[2] || '0', 10),
+    weeks: parseInt(match[3] || '0', 10),
+    days: parseInt(match[4] || '0', 10),
+    hours: parseInt(match[5] || '0', 10),
+    minutes: parseInt(match[6] || '0', 10),
+    seconds: parseInt(match[7] || '0', 10),
+  }
+}
+
+/**
+ * Add an ISO 8601 duration to a date using calendar arithmetic.
+ *
+ * Years, months, weeks and days advance the calendar (so "P1M" lands on the
+ * same day of the next month whatever its length), while hours, minutes and
+ * seconds are added as elapsed time.
+ *
+ * @param from - Anchor date
+ * @param parts - Parsed duration components
+ * @returns A new date; `from` is never mutated
+ */
+export function addIso8601Duration(from: Date, parts: Iso8601DurationParts): Date {
+  const result = new Date(from.getTime())
+
+  if (parts.years) result.setFullYear(result.getFullYear() + parts.years)
+  if (parts.months) result.setMonth(result.getMonth() + parts.months)
+
+  const days = parts.weeks * 7 + parts.days
+  if (days) result.setDate(result.getDate() + days)
+
+  const elapsedMs =
+    parts.hours * MS_PER_HOUR + parts.minutes * MS_PER_MINUTE + parts.seconds * MS_PER_SECOND
+
+  return elapsedMs ? new Date(result.getTime() + elapsedMs) : result
+}
+
 /**
- * Parse ISO 8601 duration to milliseconds
+ * Parse a duration to milliseconds
  *
  * Supports:
- * - ISO 8601: PT5M (5 minutes), PT1H (1 hour), P1D (1 day), P3D (3 days)
+ * - ISO 8601: PT30M (30 minutes), PT1H (1 hour), P1D (1 day), P1W (1 week), P1DT12H
  * - Simple formats: 5m, 1h, 3d, 30s
  *
+ * Years and months are rejected here because they have no fixed millisecond
+ * length — use `parseIso8601Duration` + `addIso8601Duration` when the duration
+ * is anchored to a date.
+ *
  * @param duration - Duration string
  * @returns Duration in milliseconds
  */
 export function parseDuration(duration: string): number {
-  // Try ISO 8601 format first: P[n]DT[n]H[n]M[n]S
-  const iso8601Regex = /P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?/
-  const iso8601Match = duration.match(iso8601Regex)
+  const parts = parseIso8601Duration(duration)
 
-  if (iso8601Match && iso8601Match[0] === duration) {
-    const days = parseInt(iso8601Match[1] || '0')
-    const hours = parseInt(iso8601Match[2] || '0')
-    const minutes = parseInt(iso8601Match[3] || '0')
-    const seconds = parseInt(iso8601Match[4] || '0')
+  if (parts) {
+    if (parts.years || parts.months) {
+      throw new Error(
+        `Duration ${duration} uses years or months, which have no fixed length in milliseconds`
+      )
+    }
 
     return (
-      days * 24 * 60 * 60 * 1000 +
-      hours * 60 * 60 * 1000 +
-      minutes * 60 * 1000 +
-      seconds * 1000
+      (parts.weeks * 7 + parts.days) * MS_PER_DAY +
+      parts.hours * MS_PER_HOUR +
+      parts.minutes * MS_PER_MINUTE +
+      parts.seconds * MS_PER_SECOND
     )
   }
 
-  // Try simple format: 1d, 5h, 30m, 45s
-  const simpleRegex = /^(\d+)(d|h|m|s)$/
-  const simpleMatch = duration.match(simpleRegex)
+  const simpleMatch = duration.match(SIMPLE_DURATION_PATTERN)
 
   if (simpleMatch) {
-    const value = parseInt(simpleMatch[1])
-    const unit = simpleMatch[2]
+    const value = parseInt(simpleMatch[1], 10)
 
-    switch (unit) {
+    switch (simpleMatch[2]) {
       case 'd':
-        return value * 24 * 60 * 60 * 1000
+        return value * MS_PER_DAY
       case 'h':
-        return value * 60 * 60 * 1000
+        return value * MS_PER_HOUR
       case 'm':
-        return value * 60 * 1000
+        return value * MS_PER_MINUTE
       case 's':
-        return value * 1000
+        return value * MS_PER_SECOND
     }
   }
 
   throw new Error(`Invalid duration format: ${duration}`)
 }
 
+/**
+ * Resolve a deadline from a duration anchored to a point in time.
+ *
+ * Accepts every format `parseDuration` accepts plus the calendar-only ISO 8601
+ * components (years, months), which are applied as calendar arithmetic. Throws
+ * on an unparseable duration — a deadline the author got wrong must surface,
+ * never quietly become some default.
+ *
+ * @param duration - Duration string (e.g. "PT30M", "P3D", "P1DT12H")
+ * @param from - Anchor date, defaults to now
+ * @returns The resolved deadline
+ */
+export function calculateDueDate(duration: string, from: Date = new Date()): Date {
+  const parts = parseIso8601Duration(duration)
+  if (parts) return addIso8601Duration(from, parts)
+
+  return new Date(from.getTime() + parseDuration(duration))
+}
+
+export function calculateWaitDelayMs(config: { duration?: string; until?: string }): number {
+  if (config.until) {
+    const targetDate = new Date(config.until)
+    if (isNaN(targetDate.getTime())) {
+      throw new Error(`WAIT activity: invalid "until" datetime: ${config.until}`)
+    }
+    const delayMs = targetDate.getTime() - Date.now()
+    return Math.max(0, delayMs)
+  }
+
+  if (config.duration) {
+    return parseDuration(config.duration)
+  }
+
+  throw new Error('WAIT activity requires "duration" (e.g., "PT5M", "1h") or "until" (ISO 8601 datetime)')
+}
+
 /**
  * Normalize a timeout value to milliseconds
  *

package/src/modules/workflows/lib/edge-reattachment.ts

@@ -0,0 +1,186 @@
+/**
+ * Route reattachment (spec section 4.1, issue #4233).
+ *
+ * Dragging a route endpoint onto another node re-targets the route instead of
+ * forcing the author to delete and redraw it. The route keeps its identity —
+ * the durable opaque `transitionId` minted by `generateTransitionId` — plus its
+ * label, condition, activities, priority and kind, so nothing an author
+ * configured is lost by moving an endpoint.
+ *
+ * Pure: the decision is taken over plain graph data and returns either the next
+ * edge list or a machine-readable rejection code the editor translates. An
+ * unaccepted reattachment simply leaves the edge list untouched, which is what
+ * makes React Flow snap the dragged endpoint back to where it started.
+ */
+
+import type { Node, Edge } from '@xyflow/react'
+import { graphToDefinition, validateWorkflowGraph } from './graph-utils'
+import { isDataMappingEdge } from './data-edge-mapping'
+import { ERROR_TRANSITION_KIND } from './error-routing'
+import { SLA_BREACH_TRANSITION_KIND } from './breach-routing'
+import { OUTCOME_TRANSITION_KIND } from './outcome-routing'
+import { resolveEdgeRouteKind, type RouteKindDescriptor } from './route-kinds'
+import { validateParallelForkJoin } from '../data/validators'
+
+/**
+ * Node types that render an error output handle
+ * (`components/nodes/ErrorOutputHandle.tsx`). An error route can only start at
+ * one of them, so moving its source endpoint elsewhere is refused rather than
+ * silently downgraded to a normal route.
+ */
+const ERROR_ROUTE_SOURCE_NODE_TYPES = new Set(['automated', 'userTask', 'subWorkflow', 'invokeAgent'])
+
+/**
+ * Node types that can raise an SLA breach — only a USER_TASK carries a deadline,
+ * so a breach route moved anywhere else would never be reachable.
+ */
+const SLA_BREACH_ROUTE_SOURCE_NODE_TYPES = new Set(['userTask'])
+
+/**
+ * Only an agent step resolves a disposition, so an outcome route (spec 7.2) can
+ * source nowhere else.
+ */
+const OUTCOME_ROUTE_SOURCE_NODE_TYPES = new Set(['invokeAgent'])
+
+/**
+ * Which node types may source each kinded route. A kind absent from this table
+ * is unrestricted; a kind present in it refuses a reattachment onto a node type
+ * that cannot reach the route, rather than leaving a dead route behind.
+ */
+const ROUTE_KIND_SOURCE_NODE_TYPES: Record<string, Set<string>> = {
+  [ERROR_TRANSITION_KIND]: ERROR_ROUTE_SOURCE_NODE_TYPES,
+  [SLA_BREACH_TRANSITION_KIND]: SLA_BREACH_ROUTE_SOURCE_NODE_TYPES,
+  [OUTCOME_TRANSITION_KIND]: OUTCOME_ROUTE_SOURCE_NODE_TYPES,
+}
+
+export type EdgeReattachRejectionCode =
+  | 'unknownRoute'
+  | 'incompleteConnection'
+  | 'unknownStep'
+  | 'selfLoop'
+  | 'duplicateRoute'
+  | 'dataMappingRoute'
+  | 'errorHandleUnsupported'
+  | 'kindHandleUnsupported'
+  | 'graphInvalid'
+  | 'forkJoinInvalid'
+
+export type EdgeReattachRejection = {
+  ok: false
+  code: EdgeReattachRejectionCode
+  detail?: string
+}
+
+export type EdgeReattachResult =
+  | { ok: true; edges: Edge[]; edge: Edge }
+  | EdgeReattachRejection
+
+export interface EdgeReattachConnection {
+  source?: string | null
+  target?: string | null
+  sourceHandle?: string | null
+  targetHandle?: string | null
+}
+
+function routeKindOfEdge(edge: Edge): RouteKindDescriptor | null {
+  const data = edge.data as { kind?: unknown } | undefined
+  return resolveEdgeRouteKind(data?.kind, edge.sourceHandle)
+}
+
+function sameHandle(left: string | null | undefined, right: string | null | undefined): boolean {
+  return (left || null) === (right || null)
+}
+
+function errorMessages(nodes: Node[], edges: Edge[]): Set<string> {
+  return new Set(
+    validateWorkflowGraph(nodes, edges)
+      .filter((issue) => issue.type === 'error')
+      .map((issue) => issue.message),
+  )
+}
+
+function forkJoinMessages(nodes: Node[], edges: Edge[]): Set<string> {
+  return new Set(validateParallelForkJoin(graphToDefinition(nodes, edges)).map((issue) => issue.message))
+}
+
+function firstAddition(before: Set<string>, after: Set<string>): string | undefined {
+  for (const message of after) {
+    if (!before.has(message)) return message
+  }
+  return undefined
+}
+
+/**
+ * Re-target one route onto a new source and/or target step.
+ *
+ * Route identity and every configured field survive: only the endpoints (and
+ * the handles they were dropped on) change. A reattachment is refused when it
+ * would create a self-loop, duplicate an existing route, move an error route
+ * off a step that can raise one, or introduce a graph or fork/join violation
+ * the current graph does not already have.
+ */
+export function reattachWorkflowEdge(
+  nodes: Node[],
+  edges: Edge[],
+  edgeId: string,
+  connection: EdgeReattachConnection,
+): EdgeReattachResult {
+  const existing = edges.find((edge) => edge.id === edgeId)
+  if (!existing) return { ok: false, code: 'unknownRoute' }
+  if (isDataMappingEdge(existing)) return { ok: false, code: 'dataMappingRoute' }
+
+  const source = connection.source ?? null
+  const target = connection.target ?? null
+  if (!source || !target) return { ok: false, code: 'incompleteConnection' }
+
+  const sourceNode = nodes.find((node) => node.id === source)
+  const targetNode = nodes.find((node) => node.id === target)
+  if (!sourceNode || !targetNode) return { ok: false, code: 'unknownStep' }
+  if (source === target) return { ok: false, code: 'selfLoop' }
+
+  const routeKind = routeKindOfEdge(existing)
+  const allowedSourceTypes = routeKind ? ROUTE_KIND_SOURCE_NODE_TYPES[routeKind.kind] : undefined
+  if (allowedSourceTypes && !allowedSourceTypes.has(sourceNode.type ?? '')) {
+    return {
+      ok: false,
+      code: routeKind?.kind === ERROR_TRANSITION_KIND
+        ? 'errorHandleUnsupported'
+        : 'kindHandleUnsupported',
+    }
+  }
+
+  // A kinded route keeps its own handle: dropping the endpoint on a node's
+  // default port must not downgrade it to a normal route.
+  const sourceHandle = routeKind
+    ? routeKind.resolveSourceHandle((existing.data ?? {}) as Record<string, unknown>)
+    : connection.sourceHandle ?? null
+  const targetHandle = connection.targetHandle ?? null
+
+  const duplicate = edges.some(
+    (edge) =>
+      edge.id !== edgeId &&
+      !isDataMappingEdge(edge) &&
+      edge.source === source &&
+      edge.target === target &&
+      sameHandle(edge.sourceHandle, sourceHandle) &&
+      sameHandle(edge.targetHandle, targetHandle),
+  )
+  if (duplicate) return { ok: false, code: 'duplicateRoute' }
+
+  const nextEdge: Edge = {
+    ...existing,
+    source,
+    target,
+    sourceHandle,
+    targetHandle,
+  }
+  const nextEdges = edges.map((edge) => (edge.id === edgeId ? nextEdge : edge))
+
+  const newGraphError = firstAddition(errorMessages(nodes, edges), errorMessages(nodes, nextEdges))
+  if (newGraphError) return { ok: false, code: 'graphInvalid', detail: newGraphError }
+
+  const newForkJoinIssue = firstAddition(forkJoinMessages(nodes, edges), forkJoinMessages(nodes, nextEdges))
+  if (newForkJoinIssue) return { ok: false, code: 'forkJoinInvalid', detail: newForkJoinIssue }
+
+  return { ok: true, edges: nextEdges, edge: nextEdge }
+}

package/src/modules/workflows/lib/edgeFormTransforms.ts

@@ -6,11 +6,10 @@
  */
 
 import type { Edge } from '@xyflow/react'
+import type { GroupCondition } from '@open-mercato/core/modules/business_rules/components/utils/conditionValidation'
 import type { Activity } from '../components/fields/ActivityArrayEditor'
 import type { TransitionCondition } from '../components/fields/BusinessRuleConditionsEditor'
-import { createLogger } from '@open-mercato/shared/lib/logger'
-
-const logger = createLogger('workflows')
+import { parseAdvancedConfigValue } from './advanced-config'
 
 /**
  * Normalized condition format (object only, no string)
@@ -30,8 +29,13 @@ export interface EdgeFormValues {
   continueOnActivityFailure: boolean
   preConditions: NormalizedCondition[]
   postConditions: NormalizedCondition[]
+  // Inline routing condition in the business_rules expression language. Edited
+  // through the same ConditionBuilder the branching inspectors use, so the
+  // condition chip on the canvas has an editor to open.
+  condition?: GroupCondition | null
   activities: Activity[]
-  advancedConfig?: string
+  // JsonBuilder emits the parsed object; legacy callers may still provide a JSON string.
+  advancedConfig?: Record<string, unknown> | string
 }
 
 /**
@@ -91,8 +95,9 @@ export function edgeToFormValues(edge: Edge): EdgeFormValues {
       : false,
     preConditions: normalizeConditions(edgeData?.preConditions || []),
     postConditions: normalizeConditions(edgeData?.postConditions || []),
+    condition: (edgeData?.condition as GroupCondition | undefined) ?? null,
     activities: edgeData?.activities || [],
-    advancedConfig: '', // Advanced config is empty initially (can be populated from edgeData if needed)
+    advancedConfig: undefined, // Advanced config is empty initially (can be populated from edgeData if needed)
   }
 }
 
@@ -113,18 +118,14 @@ export function formValuesToEdgeUpdates(
     continueOnActivityFailure: values.continueOnActivityFailure,
     preConditions: values.preConditions.length > 0 ? values.preConditions : undefined,
     postConditions: values.postConditions.length > 0 ? values.postConditions : undefined,
+    condition: values.condition ?? undefined,
     activities: values.activities.length > 0 ? values.activities : undefined,
   }
 
-  // Parse advanced config (JSON) and merge
-  if (values.advancedConfig && values.advancedConfig.trim()) {
-    try {
-      const parsed = JSON.parse(values.advancedConfig)
-      Object.assign(updates, parsed)
-    } catch (error) {
-      logger.error('Invalid JSON in Advanced Configuration', { err: error })
-      throw new Error('Invalid JSON in Advanced Configuration. Please check your syntax.')
-    }
+  // Merge the advanced config (object from JsonBuilder, or legacy JSON string)
+  const advanced = parseAdvancedConfigValue(values.advancedConfig)
+  if (advanced) {
+    Object.assign(updates, advanced)
   }
 
   return updates