chore: import upstream snapshot with attribution

apps/sim/lib/workflows/deployment-outbox.ts

@@ -0,0 +1,745 @@
+import { db, workflowDeploymentVersion, workflow as workflowTable } from '@sim/db'
+import { createLogger } from '@sim/logger'
+import { and, eq, ne } from 'drizzle-orm'
+import { NextRequest } from 'next/server'
+import {
+  enqueueOutboxEvent,
+  type OutboxHandlerRegistry,
+  type ProcessSingleOutboxResult,
+  processOutboxEventById,
+} from '@/lib/core/outbox/service'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { getBaseUrl } from '@/lib/core/utils/urls'
+import { setWorkflowMcpTransactionLockTimeout } from '@/lib/mcp/server-locks'
+import {
+  notifyMcpToolServers,
+  removeMcpToolsForWorkflow,
+  syncMcpToolsForWorkflow,
+} from '@/lib/mcp/workflow-mcp-sync'
+import { cleanupWebhooksForWorkflow, saveTriggerWebhooksForDeploy } from '@/lib/webhooks/deploy'
+import { createSchedulesForDeploy, deleteSchedulesForWorkflow } from '@/lib/workflows/schedules'
+import type { BlockState } from '@/stores/workflows/workflow/types'
+
+const logger = createLogger('WorkflowDeploymentOutbox')
+
+export const WORKFLOW_DEPLOYMENT_OUTBOX_EVENTS = {
+  SYNC_ACTIVE_SIDE_EFFECTS: 'workflow.deployment.sync-active-side-effects',
+  CLEANUP_INACTIVE_SIDE_EFFECTS: 'workflow.deployment.cleanup-inactive-side-effects',
+  CLEANUP_UNDEPLOYED_SIDE_EFFECTS: 'workflow.deployment.cleanup-undeployed-side-effects',
+} as const
+
+interface SyncActiveSideEffectsPayload {
+  workflowId: string
+  deploymentVersionId: string
+  userId: string
+  requestId?: string
+  forceRecreateSubscriptions?: boolean
+}
+
+interface CleanupUndeployedSideEffectsPayload {
+  workflowId: string
+  deploymentVersionIds: string[]
+  userId: string
+  requestId?: string
+}
+
+interface CleanupInactiveSideEffectsPayload {
+  workflowId: string
+  activeDeploymentVersionId: string
+  userId: string
+  requestId?: string
+}
+
+export async function enqueueWorkflowDeploymentSideEffects(
+  executor: Pick<typeof db, 'insert'>,
+  payload: SyncActiveSideEffectsPayload
+): Promise<string> {
+  return enqueueOutboxEvent(
+    executor,
+    WORKFLOW_DEPLOYMENT_OUTBOX_EVENTS.SYNC_ACTIVE_SIDE_EFFECTS,
+    payload,
+    { maxAttempts: 10 }
+  )
+}
+
+export async function enqueueWorkflowUndeploySideEffects(
+  executor: Pick<typeof db, 'insert'>,
+  payload: CleanupUndeployedSideEffectsPayload
+): Promise<string> {
+  return enqueueOutboxEvent(
+    executor,
+    WORKFLOW_DEPLOYMENT_OUTBOX_EVENTS.CLEANUP_UNDEPLOYED_SIDE_EFFECTS,
+    payload,
+    { maxAttempts: 10 }
+  )
+}
+
+async function enqueueWorkflowInactiveDeploymentCleanup(
+  executor: Pick<typeof db, 'insert'>,
+  payload: CleanupInactiveSideEffectsPayload
+): Promise<string> {
+  return enqueueOutboxEvent(
+    executor,
+    WORKFLOW_DEPLOYMENT_OUTBOX_EVENTS.CLEANUP_INACTIVE_SIDE_EFFECTS,
+    payload,
+    { maxAttempts: 10 }
+  )
+}
+
+export async function processWorkflowDeploymentOutboxEvent(
+  eventId: string
+): Promise<ProcessSingleOutboxResult> {
+  return processOutboxEventById(eventId, workflowDeploymentOutboxHandlers)
+}
+
+const syncActiveSideEffects = async (rawPayload: unknown): Promise<void> => {
+  const payload = parseSyncActiveSideEffectsPayload(rawPayload)
+  const requestId = payload.requestId ?? generateRequestId()
+  const [workflowRecord] = await db
+    .select()
+    .from(workflowTable)
+    .where(eq(workflowTable.id, payload.workflowId))
+    .limit(1)
+
+  if (!workflowRecord) {
+    logger.warn(`[${requestId}] Workflow missing during deployment side-effect sync`, {
+      workflowId: payload.workflowId,
+    })
+    return
+  }
+
+  const [versionRow] = await db
+    .select({
+      id: workflowDeploymentVersion.id,
+      state: workflowDeploymentVersion.state,
+      isActive: workflowDeploymentVersion.isActive,
+    })
+    .from(workflowDeploymentVersion)
+    .where(
+      and(
+        eq(workflowDeploymentVersion.workflowId, payload.workflowId),
+        eq(workflowDeploymentVersion.id, payload.deploymentVersionId)
+      )
+    )
+    .limit(1)
+
+  if (!versionRow?.isActive) {
+    logger.info(`[${requestId}] Skipping stale deployment side-effect sync`, {
+      workflowId: payload.workflowId,
+      deploymentVersionId: payload.deploymentVersionId,
+    })
+    if (versionRow) {
+      await cleanupDeploymentVersionIfInactive({
+        workflowId: payload.workflowId,
+        deploymentVersionId: payload.deploymentVersionId,
+        workflow: workflowRecord as Record<string, unknown>,
+        userId: payload.userId,
+        requestId,
+      })
+    }
+    return
+  }
+
+  const state = versionRow.state as { blocks?: Record<string, BlockState> }
+  const blocks = state.blocks ?? {}
+  const workflowData = workflowRecord as Record<string, unknown>
+
+  if (!(await cleanupStaleDeploymentIfNeeded({ payload, workflow: workflowData, requestId }))) {
+    return
+  }
+
+  const request = new NextRequest(new URL('/api/webhooks', getBaseUrl()))
+  const triggerSaveResult = await saveTriggerWebhooksForDeploy({
+    request,
+    workflowId: payload.workflowId,
+    workflow: workflowData,
+    userId: payload.userId,
+    blocks,
+    requestId,
+    deploymentVersionId: payload.deploymentVersionId,
+    forceRecreateSubscriptions: payload.forceRecreateSubscriptions ?? false,
+    strictExternalCleanup: true,
+  })
+
+  if (!triggerSaveResult.success) {
+    throw new Error(triggerSaveResult.error?.message || 'Failed to sync trigger configuration')
+  }
+
+  if (!(await cleanupStaleDeploymentIfNeeded({ payload, workflow: workflowData, requestId }))) {
+    return
+  }
+
+  const scheduleResult = await createSchedulesIfStillActive({
+    workflowId: payload.workflowId,
+    deploymentVersionId: payload.deploymentVersionId,
+    blocks,
+  })
+  if (!scheduleResult.success) {
+    throw new Error(scheduleResult.error || 'Failed to sync schedules')
+  }
+
+  if (!(await cleanupStaleDeploymentIfNeeded({ payload, workflow: workflowData, requestId }))) {
+    return
+  }
+
+  await syncMcpToolsIfStillActive({
+    workflowId: payload.workflowId,
+    deploymentVersionId: payload.deploymentVersionId,
+    requestId,
+    state,
+  })
+
+  if (!(await cleanupStaleDeploymentIfNeeded({ payload, workflow: workflowData, requestId }))) {
+    return
+  }
+
+  if (workflowRecord.workspaceId) {
+    await pruneWorkflowGroupOutputsIfStillActive({
+      workflowId: payload.workflowId,
+      deploymentVersionId: payload.deploymentVersionId,
+      workspaceId: workflowRecord.workspaceId,
+      validBlockIds: new Set(Object.keys(blocks)),
+      requestId,
+    })
+  }
+
+  if (!(await cleanupStaleDeploymentIfNeeded({ payload, workflow: workflowData, requestId }))) {
+    return
+  }
+
+  await syncInactiveDeploymentCleanup({
+    workflowId: payload.workflowId,
+    activeDeploymentVersionId: payload.deploymentVersionId,
+    workflow: workflowData,
+    userId: payload.userId,
+    requestId,
+  })
+}
+
+const cleanupInactiveSideEffects = async (rawPayload: unknown): Promise<void> => {
+  const payload = parseCleanupInactiveSideEffectsPayload(rawPayload)
+  const requestId = payload.requestId ?? generateRequestId()
+  const [workflowRecord] = await db
+    .select()
+    .from(workflowTable)
+    .where(eq(workflowTable.id, payload.workflowId))
+    .limit(1)
+
+  if (!workflowRecord) return
+
+  await cleanupInactiveDeploymentVersions({
+    workflowId: payload.workflowId,
+    activeDeploymentVersionId: payload.activeDeploymentVersionId,
+    workflow: workflowRecord as Record<string, unknown>,
+    userId: payload.userId,
+    requestId,
+  })
+}
+
+const cleanupUndeployedSideEffects = async (rawPayload: unknown): Promise<void> => {
+  const payload = parseCleanupUndeployedSideEffectsPayload(rawPayload)
+  const requestId = payload.requestId ?? generateRequestId()
+  const [workflowRecord] = await db
+    .select()
+    .from(workflowTable)
+    .where(eq(workflowTable.id, payload.workflowId))
+    .limit(1)
+
+  if (!workflowRecord) return
+  const workflowData = workflowRecord as Record<string, unknown>
+
+  for (const deploymentVersionId of payload.deploymentVersionIds) {
+    const [versionRow] = await db
+      .select({ isActive: workflowDeploymentVersion.isActive })
+      .from(workflowDeploymentVersion)
+      .where(
+        and(
+          eq(workflowDeploymentVersion.workflowId, payload.workflowId),
+          eq(workflowDeploymentVersion.id, deploymentVersionId)
+        )
+      )
+      .limit(1)
+
+    if (!versionRow || versionRow.isActive) continue
+    await cleanupDeploymentVersionIfInactive({
+      workflowId: payload.workflowId,
+      workflow: workflowData,
+      userId: payload.userId,
+      requestId,
+      deploymentVersionId,
+    })
+  }
+
+  await cleanupNullVersionWebhooksIfStillUndeployed({
+    workflowId: payload.workflowId,
+    workflow: workflowData,
+    requestId,
+  })
+
+  await removeMcpToolsIfStillUndeployed(payload.workflowId, requestId)
+}
+
+/**
+ * Run inactive-version cleanup synchronously as part of the active-version sync, right
+ * after the active version's webhooks/schedules are registered.
+ *
+ * {@link cleanupInactiveDeploymentVersions} re-checks that each version is still inactive
+ * before tearing anything down, so it can never touch the now-active version. Running it
+ * inline — rather than only enqueueing it — closes the window where a lost
+ * `CLEANUP_INACTIVE` outbox event leaves superseded webhooks behind as live-but-never-polled
+ * `is_active` orphans. The deferred event is kept as a fallback so cleanup still retries if
+ * the inline pass throws, without failing the already-succeeded registration.
+ */
+async function syncInactiveDeploymentCleanup(params: {
+  workflowId: string
+  activeDeploymentVersionId: string
+  workflow: Record<string, unknown>
+  userId: string
+  requestId: string
+}): Promise<void> {
+  try {
+    await cleanupInactiveDeploymentVersions(params)
+  } catch (cleanupError) {
+    logger.warn(
+      `[${params.requestId}] Inline inactive-deployment cleanup failed; deferring to outbox retry`,
+      cleanupError
+    )
+    await enqueueWorkflowInactiveDeploymentCleanup(db, {
+      workflowId: params.workflowId,
+      activeDeploymentVersionId: params.activeDeploymentVersionId,
+      userId: params.userId,
+      requestId: params.requestId,
+    })
+  }
+}
+
+async function cleanupInactiveDeploymentVersions(params: {
+  workflowId: string
+  activeDeploymentVersionId: string
+  workflow: Record<string, unknown>
+  userId: string
+  requestId: string
+}): Promise<void> {
+  const inactiveVersions = await db
+    .select({ id: workflowDeploymentVersion.id })
+    .from(workflowDeploymentVersion)
+    .where(
+      and(
+        eq(workflowDeploymentVersion.workflowId, params.workflowId),
+        ne(workflowDeploymentVersion.id, params.activeDeploymentVersionId),
+        eq(workflowDeploymentVersion.isActive, false)
+      )
+    )
+
+  for (const version of inactiveVersions) {
+    await cleanupDeploymentVersionIfInactive({
+      workflowId: params.workflowId,
+      workflow: params.workflow,
+      userId: params.userId,
+      requestId: params.requestId,
+      deploymentVersionId: version.id,
+    })
+  }
+}
+
+async function cleanupDeploymentVersionIfInactive(params: {
+  workflowId: string
+  deploymentVersionId: string
+  workflow: Record<string, unknown>
+  userId: string
+  requestId: string
+}): Promise<void> {
+  if (await isDeploymentVersionActive(params.workflowId, params.deploymentVersionId)) {
+    await enqueueWorkflowDeploymentSideEffects(db, {
+      workflowId: params.workflowId,
+      deploymentVersionId: params.deploymentVersionId,
+      userId: params.userId,
+      requestId: params.requestId,
+      forceRecreateSubscriptions: true,
+    })
+    return
+  }
+
+  const isStillInactive = async () =>
+    !(await isDeploymentVersionActive(params.workflowId, params.deploymentVersionId))
+
+  await cleanupWebhooksForWorkflow(
+    params.workflowId,
+    params.workflow,
+    params.requestId,
+    params.deploymentVersionId,
+    false,
+    true,
+    isStillInactive
+  )
+
+  if (!(await isStillInactive())) {
+    await enqueueWorkflowDeploymentSideEffects(db, {
+      workflowId: params.workflowId,
+      deploymentVersionId: params.deploymentVersionId,
+      userId: params.userId,
+      requestId: params.requestId,
+      forceRecreateSubscriptions: true,
+    })
+    return
+  }
+
+  const deletedSchedules = await deleteSchedulesForDeploymentIfInactive({
+    workflowId: params.workflowId,
+    deploymentVersionId: params.deploymentVersionId,
+  })
+  if (!deletedSchedules) {
+    if (await isDeploymentVersionActive(params.workflowId, params.deploymentVersionId)) {
+      await enqueueWorkflowDeploymentSideEffects(db, {
+        workflowId: params.workflowId,
+        deploymentVersionId: params.deploymentVersionId,
+        userId: params.userId,
+        requestId: params.requestId,
+        forceRecreateSubscriptions: true,
+      })
+    }
+    return
+  }
+
+  if (await isDeploymentVersionActive(params.workflowId, params.deploymentVersionId)) {
+    await enqueueWorkflowDeploymentSideEffects(db, {
+      workflowId: params.workflowId,
+      deploymentVersionId: params.deploymentVersionId,
+      userId: params.userId,
+      requestId: params.requestId,
+      forceRecreateSubscriptions: true,
+    })
+  }
+}
+
+async function deleteSchedulesForDeploymentIfInactive(params: {
+  workflowId: string
+  deploymentVersionId: string
+}): Promise<boolean> {
+  return db.transaction(async (tx) => {
+    const [versionRow] = await tx
+      .select({ id: workflowDeploymentVersion.id })
+      .from(workflowDeploymentVersion)
+      .where(
+        and(
+          eq(workflowDeploymentVersion.workflowId, params.workflowId),
+          eq(workflowDeploymentVersion.id, params.deploymentVersionId),
+          eq(workflowDeploymentVersion.isActive, false)
+        )
+      )
+      .limit(1)
+      .for('update')
+
+    if (!versionRow) return false
+
+    await deleteSchedulesForWorkflow(params.workflowId, tx, params.deploymentVersionId)
+    return true
+  })
+}
+
+async function cleanupStaleDeploymentIfNeeded(params: {
+  payload: SyncActiveSideEffectsPayload
+  workflow: Record<string, unknown>
+  requestId: string
+}): Promise<boolean> {
+  if (
+    await isDeploymentVersionActive(params.payload.workflowId, params.payload.deploymentVersionId)
+  ) {
+    return true
+  }
+
+  logger.info(`[${params.requestId}] Cleaning up stale deployment side effects`, {
+    workflowId: params.payload.workflowId,
+    deploymentVersionId: params.payload.deploymentVersionId,
+  })
+  await cleanupDeploymentVersionIfInactive({
+    workflowId: params.payload.workflowId,
+    workflow: params.workflow,
+    userId: params.payload.userId,
+    requestId: params.requestId,
+    deploymentVersionId: params.payload.deploymentVersionId,
+  })
+  return false
+}
+
+async function isDeploymentVersionActive(
+  workflowId: string,
+  deploymentVersionId: string
+): Promise<boolean> {
+  const [versionRow] = await db
+    .select({ id: workflowDeploymentVersion.id })
+    .from(workflowDeploymentVersion)
+    .where(
+      and(
+        eq(workflowDeploymentVersion.workflowId, workflowId),
+        eq(workflowDeploymentVersion.id, deploymentVersionId),
+        eq(workflowDeploymentVersion.isActive, true)
+      )
+    )
+    .limit(1)
+
+  return Boolean(versionRow)
+}
+
+async function removeMcpToolsIfStillUndeployed(
+  workflowId: string,
+  requestId: string
+): Promise<void> {
+  const tools = await db.transaction(async (tx) => {
+    await setWorkflowMcpTransactionLockTimeout(tx)
+
+    const [workflowRecord] = await tx
+      .select({ id: workflowTable.id, isDeployed: workflowTable.isDeployed })
+      .from(workflowTable)
+      .where(eq(workflowTable.id, workflowId))
+      .for('update')
+      .limit(1)
+
+    if (!workflowRecord || workflowRecord.isDeployed) return []
+    return removeMcpToolsForWorkflow(workflowId, requestId, tx, true)
+  })
+  notifyMcpToolServers(tools)
+}
+
+async function cleanupNullVersionWebhooksIfStillUndeployed(params: {
+  workflowId: string
+  workflow: Record<string, unknown>
+  requestId: string
+}): Promise<void> {
+  const isStillUndeployed = async () => {
+    const [workflowRecord] = await db
+      .select({ isDeployed: workflowTable.isDeployed })
+      .from(workflowTable)
+      .where(eq(workflowTable.id, params.workflowId))
+      .limit(1)
+
+    return Boolean(workflowRecord && !workflowRecord.isDeployed)
+  }
+
+  if (!(await isStillUndeployed())) return
+  await cleanupWebhooksForWorkflow(
+    params.workflowId,
+    params.workflow,
+    params.requestId,
+    null,
+    false,
+    true,
+    isStillUndeployed
+  )
+}
+
+async function syncMcpToolsIfStillActive(params: {
+  workflowId: string
+  deploymentVersionId: string
+  requestId: string
+  state: { blocks?: Record<string, unknown> }
+}): Promise<void> {
+  const tools = await db.transaction(async (tx) => {
+    await setWorkflowMcpTransactionLockTimeout(tx)
+
+    const [workflowRecord] = await tx
+      .select({ id: workflowTable.id })
+      .from(workflowTable)
+      .where(eq(workflowTable.id, params.workflowId))
+      .for('update')
+      .limit(1)
+
+    if (!workflowRecord) return []
+
+    const [versionRow] = await tx
+      .select({ id: workflowDeploymentVersion.id })
+      .from(workflowDeploymentVersion)
+      .where(
+        and(
+          eq(workflowDeploymentVersion.workflowId, params.workflowId),
+          eq(workflowDeploymentVersion.id, params.deploymentVersionId),
+          eq(workflowDeploymentVersion.isActive, true)
+        )
+      )
+      .limit(1)
+
+    if (!versionRow) return []
+
+    return syncMcpToolsForWorkflow({
+      workflowId: params.workflowId,
+      requestId: params.requestId,
+      state: params.state,
+      context: 'deployment-outbox',
+      tx,
+      notify: false,
+      throwOnError: true,
+    })
+  })
+  notifyMcpToolServers(tools)
+}
+
+async function createSchedulesIfStillActive(params: {
+  workflowId: string
+  deploymentVersionId: string
+  blocks: Record<string, BlockState>
+}) {
+  return db.transaction(async (tx) => {
+    const [workflowRecord] = await tx
+      .select({ id: workflowTable.id })
+      .from(workflowTable)
+      .where(eq(workflowTable.id, params.workflowId))
+      .limit(1)
+      .for('update')
+
+    if (!workflowRecord) {
+      return { success: true as const }
+    }
+
+    const [versionRow] = await tx
+      .select({ id: workflowDeploymentVersion.id })
+      .from(workflowDeploymentVersion)
+      .where(
+        and(
+          eq(workflowDeploymentVersion.workflowId, params.workflowId),
+          eq(workflowDeploymentVersion.id, params.deploymentVersionId),
+          eq(workflowDeploymentVersion.isActive, true)
+        )
+      )
+      .limit(1)
+
+    if (!versionRow) {
+      return { success: true as const }
+    }
+
+    const result = await createSchedulesForDeploy(
+      params.workflowId,
+      params.blocks,
+      tx,
+      params.deploymentVersionId
+    )
+    if (!result.success) {
+      throw new Error(result.error || 'Failed to sync schedules')
+    }
+    return result
+  })
+}
+
+async function pruneWorkflowGroupOutputsIfStillActive(params: {
+  workflowId: string
+  deploymentVersionId: string
+  workspaceId: string
+  validBlockIds: Set<string>
+  requestId: string
+}): Promise<void> {
+  await db.transaction(async (tx) => {
+    const [workflowRecord] = await tx
+      .select({ id: workflowTable.id })
+      .from(workflowTable)
+      .where(eq(workflowTable.id, params.workflowId))
+      .limit(1)
+      .for('update')
+
+    if (!workflowRecord) return
+
+    const [versionRow] = await tx
+      .select({ id: workflowDeploymentVersion.id })
+      .from(workflowDeploymentVersion)
+      .where(
+        and(
+          eq(workflowDeploymentVersion.workflowId, params.workflowId),
+          eq(workflowDeploymentVersion.id, params.deploymentVersionId),
+          eq(workflowDeploymentVersion.isActive, true)
+        )
+      )
+      .limit(1)
+
+    if (!versionRow) return
+
+    const { pruneStaleWorkflowGroupOutputs } = await import('@/lib/table/workflow-groups/service')
+    await pruneStaleWorkflowGroupOutputs({
+      workflowId: params.workflowId,
+      workspaceId: params.workspaceId,
+      validBlockIds: params.validBlockIds,
+      requestId: params.requestId,
+      tx,
+    })
+  })
+}
+
+function parseSyncActiveSideEffectsPayload(payload: unknown): SyncActiveSideEffectsPayload {
+  const record = parsePayloadRecord(payload)
+  const workflowId = parseRequiredString(record.workflowId, 'workflowId')
+  const deploymentVersionId = parseRequiredString(record.deploymentVersionId, 'deploymentVersionId')
+  const userId = parseRequiredString(record.userId, 'userId')
+  const requestId =
+    typeof record.requestId === 'string' && record.requestId.length > 0
+      ? record.requestId
+      : undefined
+  const forceRecreateSubscriptions =
+    typeof record.forceRecreateSubscriptions === 'boolean'
+      ? record.forceRecreateSubscriptions
+      : undefined
+
+  return { workflowId, deploymentVersionId, userId, requestId, forceRecreateSubscriptions }
+}
+
+function parseCleanupUndeployedSideEffectsPayload(
+  payload: unknown
+): CleanupUndeployedSideEffectsPayload {
+  const record = parsePayloadRecord(payload)
+  const workflowId = parseRequiredString(record.workflowId, 'workflowId')
+  const userId = parseRequiredString(record.userId, 'userId')
+  const deploymentVersionIds = parseRequiredStringArray(
+    record.deploymentVersionIds,
+    'deploymentVersionIds'
+  )
+  const requestId =
+    typeof record.requestId === 'string' && record.requestId.length > 0
+      ? record.requestId
+      : undefined
+
+  return { workflowId, deploymentVersionIds, userId, requestId }
+}
+
+function parseCleanupInactiveSideEffectsPayload(
+  payload: unknown
+): CleanupInactiveSideEffectsPayload {
+  const record = parsePayloadRecord(payload)
+  const workflowId = parseRequiredString(record.workflowId, 'workflowId')
+  const activeDeploymentVersionId = parseRequiredString(
+    record.activeDeploymentVersionId,
+    'activeDeploymentVersionId'
+  )
+  const userId = parseRequiredString(record.userId, 'userId')
+  const requestId =
+    typeof record.requestId === 'string' && record.requestId.length > 0
+      ? record.requestId
+      : undefined
+
+  return { workflowId, activeDeploymentVersionId, userId, requestId }
+}
+
+function parsePayloadRecord(payload: unknown): Record<string, unknown> {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    throw new Error('Deployment outbox payload must be an object')
+  }
+  return payload as Record<string, unknown>
+}
+
+function parseRequiredString(value: unknown, fieldName: string): string {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`Deployment outbox payload is missing ${fieldName}`)
+  }
+  return value
+}
+
+function parseRequiredStringArray(value: unknown, fieldName: string): string[] {
+  if (
+    !Array.isArray(value) ||
+    value.some((item) => typeof item !== 'string' || item.length === 0)
+  ) {
+    throw new Error(`Deployment outbox payload is missing ${fieldName}`)
+  }
+  return value
+}
+
+export const workflowDeploymentOutboxHandlers: OutboxHandlerRegistry = {
+  [WORKFLOW_DEPLOYMENT_OUTBOX_EVENTS.SYNC_ACTIVE_SIDE_EFFECTS]: syncActiveSideEffects,
+  [WORKFLOW_DEPLOYMENT_OUTBOX_EVENTS.CLEANUP_INACTIVE_SIDE_EFFECTS]: cleanupInactiveSideEffects,
+  [WORKFLOW_DEPLOYMENT_OUTBOX_EVENTS.CLEANUP_UNDEPLOYED_SIDE_EFFECTS]: cleanupUndeployedSideEffects,
+}