Function promoteFork

apps/sim/lib/workspaces/fork/promote/promote.ts:334–902

(params: PromoteForkParams)

 * without mutating only when required references are unmapped.
 */
export async function promoteFork(params: PromoteForkParams): Promise<PromoteForkResult> {
  const { edge, sourceWorkspaceId, targetWorkspaceId, direction, userId } = params
  const requestId = params.requestId ?? 'unknown'

  // Distinguish an OMITTED dependent mapping (leave the store as-is) from an explicit empty
  // array (clear it). When values are PROVIDED the apply map is plan-independent, so build it
  // here - BEFORE the transaction - to keep the advisory lock tight (pure in-memory, no DB),
  // mirroring how the source states are pre-loaded above. The OMITTED path needs the plan's
  // replace targets, so it loads + builds inside the tx below.
  const dependentValuesProvided = params.dependentValues !== undefined
  const providedOverridesByWorkflow = dependentValuesProvided
    ? groupDependentOverrides(
        (params.dependentValues ?? []).map((entry) => ({
          targetWorkflowId: entry.workflowId,
          targetBlockId: entry.blockId,
          subBlockKey: entry.subBlockKey,
          value: entry.value,
        }))
      )
    : null

  const targetMembers = (await getUsersWithPermissions(targetWorkspaceId)).map((m) => m.userId)

  // Read the source's deployed workflows + states BEFORE the transaction so these
  // heavy per-workflow reads never check out a second pooled connection from inside
  // the promote tx (which can deadlock the pool at saturation). The source is
  // read-only here, so this pre-tx snapshot is exactly what gets force-pushed.
  const { deployedWorkflows, sourceStates } = await loadSourceDeployedStates(sourceWorkspaceId)

  const txResult: PromoteTxBlocked | PromoteTxApplied = await db.transaction(async (tx) => {
    // Bound lock waits so a contended sync into this target fails fast instead of
    // stagnating the pool. Must run before acquiring the advisory locks below.
    await setForkLockTimeout(tx)
    // Target lock before edge lock (consistent ordering): the target lock serializes
    // every sync into this target so sibling forks can't interleave writes, and so
    // rollback's "newest sync" check stays race-free against a concurrent promote.
    await acquireForkTargetLock(tx, targetWorkspaceId)
    await acquireForkEdgeLock(tx, edge.childWorkspaceId)

    const plan = await computeForkPromotePlan({
      executor: tx,
      edge,
      sourceWorkspaceId,
      targetWorkspaceId,
      direction,
      deployedSourceWorkflows: deployedWorkflows,
      sourceStates,
    })

    const now = new Date()

    // Copy the selected referenced-but-unmapped resources into the target BEFORE the gate, so a
    // user can copy rather than map each one. The gate is evaluated against the post-copy state
    // (the copy resolves the selected refs), so the copy only runs when the sync will actually
    // proceed - if required refs remain unmapped, we block without copying anything.
    const { selection: copySelection, willResolve } = buildPromoteCopySelection(
      params.copyResources,
      plan.copyableUnmapped