@uipath/packager-tool-workflowcompiler 0.0.14

package/dist/index.js

@@ -0,0 +1,1213 @@
+// src/i18n/index.ts
+import { I18nManager } from "@uipath/solutionpackager-tool-core";
+// src/i18n/locales/de.json
+var de_default = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+
+// src/i18n/locales/en.ts
+var en = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+// src/i18n/locales/es.json
+var es_default = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+// src/i18n/locales/es-MX.json
+var es_MX_default = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+// src/i18n/locales/fr.json
+var fr_default = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+// src/i18n/locales/ja.json
+var ja_default = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+// src/i18n/locales/ko.json
+var ko_default = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+// src/i18n/locales/pt.json
+var pt_default = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+// src/i18n/locales/pt-BR.json
+var pt_BR_default = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+// src/i18n/locales/ro.json
+var ro_default = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+// src/i18n/locales/ru.json
+var ru_default = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+// src/i18n/locales/tr.json
+var tr_default = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+// src/i18n/locales/zh-CN.json
+var zh_CN_default = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+// src/i18n/locales/zh-TW.json
+var zh_TW_default = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+// src/i18n/locales/zu.json
+var zu_default = {
+  toolWorkflowcompiler: {
+    lifecycle: {
+      started: "[WorkflowCompiler] {operation} started",
+      command: "[WorkflowCompiler] Command: {command}",
+      completed: "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+      cancelled: "[WorkflowCompiler] Operation cancelled"
+    },
+    errors: {
+      processExited: "Process exited with code {exitCode}",
+      failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+      processError: "[WorkflowCompiler] Process error: {message}",
+      startFailed: "Failed to start workflow compiler: {message}",
+      operationCancelled: "Operation cancelled"
+    },
+    pathResolver: {
+      info: {
+        usingCached: "[PathResolver] Using cached compiler path: {path}",
+        usingExplicitPath: "[PathResolver] Using explicit compiler path: {path}",
+        resolving: "[PathResolver] Resolving workflow compiler path...",
+        checkingEnvVar: "[PathResolver] Checking environment variable location: {path}",
+        foundViaEnv: "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+        checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}",
+        foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache",
+        notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...",
+        restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+        runningDotnetRestore: "[PathResolver] Running dotnet restore...",
+        restoreCompleted: "[PathResolver] dotnet restore completed",
+        installCompleted: "[PathResolver] Compiler restored successfully",
+        cleaningUp: "[PathResolver] Cleaning up temp directory",
+        resolved: "[PathResolver] Compiler resolved at: {path}"
+      },
+      errors: {
+        unsupportedPlatform: "Unsupported platform: {platform}",
+        compilerNotFoundAfterRestore: "Compiler not found in NuGet cache after dotnet restore.",
+        dotnetRestoreFailed: "dotnet restore failed: {details}"
+      }
+    }
+  }
+};
+
+// src/i18n/index.ts
+I18nManager.registerTranslations("en", en);
+I18nManager.registerTranslations("de", de_default);
+I18nManager.registerTranslations("es", es_default);
+I18nManager.registerTranslations("es-MX", es_MX_default);
+I18nManager.registerTranslations("fr", fr_default);
+I18nManager.registerTranslations("ja", ja_default);
+I18nManager.registerTranslations("ko", ko_default);
+I18nManager.registerTranslations("pt", pt_default);
+I18nManager.registerTranslations("pt-BR", pt_BR_default);
+I18nManager.registerTranslations("ro", ro_default);
+I18nManager.registerTranslations("ru", ru_default);
+I18nManager.registerTranslations("tr", tr_default);
+I18nManager.registerTranslations("zh-CN", zh_CN_default);
+I18nManager.registerTranslations("zh-TW", zh_TW_default);
+I18nManager.registerTranslations("zu", zu_default);
+
+// src/index.ts
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+
+// src/workflow-compiler-tool-factory.ts
+import {
+  ProjectTypes
+} from "@uipath/solutionpackager-tool-core";
+
+// src/workflow-compiler-tool.ts
+import {
+  LogLevel,
+  ProjectTool
+} from "@uipath/solutionpackager-tool-core";
+
+// src/workflow-compiler-executor.ts
+import { spawn } from "node:child_process";
+import {
+  ToolErrorCodes,
+  ToolResult,
+  translate as translate2
+} from "@uipath/solutionpackager-tool-core";
+
+// src/workflow-compiler-path-resolver.ts
+import { execFileSync } from "node:child_process";
+import { homedir, platform } from "node:os";
+import {
+  Path,
+  TemporaryStorageService,
+  translate
+} from "@uipath/solutionpackager-tool-core";
+
+// src/workflow-compiler-config.ts
+var DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.0-alpha.22366";
+var workflowCompilerConfig = {
+  workflowCompilerPath: undefined,
+  workflowCompilerVersion: DEFAULT_WORKFLOW_COMPILER_VERSION
+};
+function setupWorkflowCompiler(options) {
+  if (options.compilerPath !== undefined) {
+    workflowCompilerConfig.workflowCompilerPath = options.compilerPath;
+  }
+  if (options.version !== undefined) {
+    workflowCompilerConfig.workflowCompilerVersion = options.version;
+  }
+}
+
+// src/workflow-compiler-path-resolver.ts
+var NUGET_FEED_URL = "https://uipath.pkgs.visualstudio.com/Public.Feeds/_packaging/UiPath-Internal/nuget/v3/index.json";
+var PLATFORM_PACKAGES = {
+  win32: {
+    packageId: "UiPath.WorkflowCompiler.Windows",
+    compilerFileName: "UiPath.WorkflowCompiler.exe"
+  },
+  darwin: {
+    packageId: "UiPath.WorkflowCompiler.macOS",
+    compilerFileName: "UiPath.WorkflowCompiler.dll"
+  },
+  linux: {
+    packageId: "UiPath.WorkflowCompiler.Linux",
+    compilerFileName: "UiPath.WorkflowCompiler.dll"
+  }
+};
+var RESTORE_CSPROJ_TEMPLATE = `<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="{packageId}" Version="{version}" />
+  </ItemGroup>
+</Project>`;
+var EMPTY_NUGET_CONFIG = `<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+</configuration>`;
+
+class WorkflowCompilerPathResolver {
+  logger;
+  fileSystem;
+  static instance = null;
+  cachedPath = null;
+  pendingResolution = null;
+  tempStorage;
+  constructor(logger, fileSystem) {
+    this.logger = logger;
+    this.fileSystem = fileSystem;
+    this.tempStorage = new TemporaryStorageService(fileSystem);
+  }
+  static getInstance(logger, fileSystem) {
+    if (!WorkflowCompilerPathResolver.instance) {
+      WorkflowCompilerPathResolver.instance = new WorkflowCompilerPathResolver(logger, fileSystem);
+    }
+    return WorkflowCompilerPathResolver.instance;
+  }
+  async getCompilerPathAsync() {
+    if (this.cachedPath) {
+      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.usingCached", { path: this.cachedPath }));
+      return this.cachedPath;
+    }
+    if (this.pendingResolution) {
+      return this.pendingResolution;
+    }
+    this.pendingResolution = this.resolveCompilerPath();
+    this.cachedPath = await this.pendingResolution;
+    this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.resolved", {
+      path: this.cachedPath
+    }));
+    return this.cachedPath;
+  }
+  async resolveCompilerPath() {
+    this.logger.info("[PathResolver] resolveCompilerPath started");
+    if (workflowCompilerConfig.workflowCompilerPath) {
+      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.usingExplicitPath", { path: workflowCompilerConfig.workflowCompilerPath }));
+      return workflowCompilerConfig.workflowCompilerPath;
+    }
+    this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.resolving"));
+    const envPath = await this.findInEnvLocation();
+    if (envPath)
+      return envPath;
+    const version = workflowCompilerConfig.workflowCompilerVersion;
+    const compilerPath = this.getNuGetCompilerPath(version);
+    this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.checkingNuGetCache", { path: compilerPath }));
+    if (await this.fileSystem.exists(compilerPath)) {
+      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.foundInNuGetCache"));
+      return compilerPath;
+    }
+    this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.notFoundStartingInstall"));
+    return this.restoreAndResolve(compilerPath, version);
+  }
+  async findInEnvLocation() {
+    const location = process.env.UIPATH_WORKFLOWCOMPILER_LOCATION;
+    if (!location)
+      return null;
+    this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.checkingEnvVar", { path: location }));
+    if ((location.endsWith(".dll") || location.endsWith(".exe")) && await this.fileSystem.exists(location)) {
+      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.foundViaEnv"));
+      return location;
+    }
+    return null;
+  }
+  async restoreAndResolve(compilerPath, version) {
+    const { packageId } = this.getPlatformInfo();
+    const tempDir = await this.tempStorage.getTempFolderPath();
+    try {
+      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.restoringPackage", { packageName: packageId, version, platform: platform() }));
+      const csproj = RESTORE_CSPROJ_TEMPLATE.replace("{packageId}", packageId).replace("{version}", version);
+      await this.fileSystem.writeFile(Path.join(tempDir, "restore.csproj"), csproj);
+      await this.fileSystem.writeFile(Path.join(tempDir, "nuget.config"), EMPTY_NUGET_CONFIG);
+      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.runningDotnetRestore"));
+      try {
+        execFileSync("dotnet", [
+          "restore",
+          "--source",
+          NUGET_FEED_URL,
+          "--source",
+          "https://api.nuget.org/v3/index.json"
+        ], {
+          cwd: tempDir,
+          stdio: "pipe"
+        });
+      } catch (error) {
+        const err = error;
+        const stderr = err?.stderr ? String(err.stderr).trim() : "";
+        const stdout = err?.stdout ? String(err.stdout).trim() : "";
+        const details = stderr || stdout || (error instanceof Error ? error.message : String(error));
+        throw new Error(translate.t("toolWorkflowcompiler.pathResolver.errors.dotnetRestoreFailed", { details }));
+      }
+      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.restoreCompleted"));
+      if (!await this.fileSystem.exists(compilerPath)) {
+        throw new Error(translate.t("toolWorkflowcompiler.pathResolver.errors.compilerNotFoundAfterRestore"));
+      }
+      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.installCompleted"));
+      return compilerPath;
+    } finally {
+      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.cleaningUp"));
+      await this.tempStorage.cleanup();
+    }
+  }
+  getPlatformInfo() {
+    const info = PLATFORM_PACKAGES[platform()];
+    if (!info) {
+      throw new Error(translate.t("toolWorkflowcompiler.pathResolver.errors.unsupportedPlatform", { platform: platform() }));
+    }
+    return info;
+  }
+  getNuGetCompilerPath(version) {
+    const cacheRoot = process.env.NUGET_PACKAGES ?? Path.join(homedir(), ".nuget", "packages");
+    const { packageId, compilerFileName } = this.getPlatformInfo();
+    return Path.join(cacheRoot, packageId.toLowerCase(), version.toLowerCase(), "WorkflowCompiler", compilerFileName);
+  }
+}
+
+// src/workflow-compiler-executor.ts
+function camelCaseKeys(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(camelCaseKeys);
+  }
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key.charAt(0).toLowerCase() + key.slice(1)] = camelCaseKeys(value);
+    }
+    return result;
+  }
+  return obj;
+}
+
+class WorkflowCompilerExecutor {
+  logger;
+  static DOTNET_EXECUTABLE = "dotnet";
+  pathResolver;
+  constructor(logger, fileSystem) {
+    this.logger = logger;
+    this.pathResolver = WorkflowCompilerPathResolver.getInstance(logger, fileSystem);
+  }
+  async executeAsync(operation, args, cancellationToken) {
+    const startTime = Date.now();
+    const compilerPath = await this.pathResolver.getCompilerPathAsync();
+    const isDll = compilerPath.endsWith(".dll");
+    const executable = isDll ? WorkflowCompilerExecutor.DOTNET_EXECUTABLE : compilerPath;
+    const commandArgs = isDll ? [compilerPath, operation, ...args] : [operation, ...args];
+    this.logCommandStart(operation, executable, commandArgs);
+    return new Promise((resolve) => {
+      let result = null;
+      const fallbackErrors = [];
+      const childProcess = this.spawnProcess(executable, commandArgs);
+      let stdoutEnded = false;
+      let stderrEnded = false;
+      let processExited = false;
+      const checkComplete = () => {
+        if (stdoutEnded && stderrEnded && processExited) {
+          const elapsed = Date.now() - startTime;
+          if (result) {
+            result.elapsed = elapsed;
+            this.logger.info(translate2.t("toolWorkflowcompiler.lifecycle.completed", {
+              operation,
+              elapsed: elapsed.toString(),
+              errorCode: result.errorCode
+            }));
+            resolve(new ToolResult(result.errorCode, result.message, result.outputPackages));
+          } else {
+            const exitCode = childProcess.exitCode ?? -1;
+            const errorMessage = fallbackErrors.join(`
+`) || translate2.t("toolWorkflowcompiler.errors.processExited", {
+              exitCode: exitCode.toString()
+            });
+            this.logger.error(translate2.t("toolWorkflowcompiler.errors.failed", {
+              operation,
+              errorMessage
+            }));
+            resolve(new ToolResult(ToolErrorCodes.InternalError, errorMessage, []));
+          }
+        }
+      };
+      const streamCompletion = {
+        markStdoutEnded: () => {
+          stdoutEnded = true;
+          checkComplete();
+        },
+        markStderrEnded: () => {
+          stderrEnded = true;
+          checkComplete();
+        },
+        markProcessExited: () => {
+          processExited = true;
+          checkComplete();
+        }
+      };
+      this.setupStdoutHandling(childProcess, streamCompletion, (r) => result = r);
+      this.setupStderrHandling(childProcess, streamCompletion, fallbackErrors);
+      this.setupProcessEventHandlers(childProcess, streamCompletion, resolve);
+      this.setupCancellationHandler(childProcess, cancellationToken, resolve);
+    });
+  }
+  spawnProcess(command, args) {
+    return spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false,
+      windowsHide: true
+    });
+  }
+  logCommandStart(operation, executable, commandArgs) {
+    const fullCommand = [executable, ...commandArgs];
+    this.logger.info(translate2.t("toolWorkflowcompiler.lifecycle.started", {
+      operation
+    }));
+    this.logger.info(translate2.t("toolWorkflowcompiler.lifecycle.command", {
+      command: fullCommand.join(" ")
+    }));
+  }
+  setupStdoutHandling(childProcess, streamCompletion, onResult) {
+    if (!childProcess.stdout) {
+      streamCompletion.markStdoutEnded();
+      return;
+    }
+    let buffer = "";
+    childProcess.stdout.on("data", (data) => {
+      buffer += data.toString();
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop();
+      for (const line of lines) {
+        if (!line.trim())
+          continue;
+        this.processOutputLine(line, onResult);
+      }
+    });
+    childProcess.stdout.on("end", () => {
+      if (buffer.trim()) {
+        this.processOutputLine(buffer, onResult);
+      }
+      streamCompletion.markStdoutEnded();
+    });
+  }
+  processOutputLine(line, onResult) {
+    const entry = this.parseOutputEntry(line);
+    if (!entry)
+      return;
+    if (entry.type === "Result") {
+      onResult(entry);
+    } else if (entry.type === "Log") {
+      this.logMessage(entry);
+    } else if (entry.type === "Progress") {
+      this.logProgress(entry);
+    }
+  }
+  logMessage(log) {
+    switch (log.logLevel) {
+      case "Information":
+        this.logger.info(log.message);
+        break;
+      case "Warning":
+        this.logger.warn(log.message);
+        break;
+      case "Error":
+        this.logger.error(log.message);
+        break;
+    }
+  }
+  logProgress(progress) {
+    const percent = progress.percentage ? `${progress.percentage}%` : "";
+    const separator = percent && progress.message ? " - " : "";
+    this.logger.progress(`${percent}${separator}${progress.message ?? ""}`);
+  }
+  setupStderrHandling(childProcess, streamCompletion, fallbackErrors) {
+    if (!childProcess.stderr) {
+      streamCompletion.markStderrEnded();
+      return;
+    }
+    let buffer = "";
+    childProcess.stderr.on("data", (data) => {
+      buffer += data.toString();
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop();
+      for (const line of lines) {
+        if (!line.trim())
+          continue;
+        this.processErrorLine(line, fallbackErrors);
+      }
+    });
+    childProcess.stderr.on("end", () => {
+      if (buffer.trim()) {
+        this.processErrorLine(buffer, fallbackErrors);
+      }
+      streamCompletion.markStderrEnded();
+    });
+  }
+  processErrorLine(line, fallbackErrors) {
+    const entry = this.parseOutputEntry(line);
+    if (entry && entry.type === "Log") {
+      this.logger.error(entry.message);
+    } else {
+      fallbackErrors.push(line);
+      this.logger.error(line);
+    }
+  }
+  setupProcessEventHandlers(childProcess, streamCompletion, resolve) {
+    childProcess.on("exit", () => streamCompletion.markProcessExited());
+    childProcess.on("error", (error) => {
+      this.logger.error(translate2.t("toolWorkflowcompiler.errors.processError", {
+        message: error.message
+      }));
+      resolve(new ToolResult(ToolErrorCodes.InternalError, translate2.t("toolWorkflowcompiler.errors.startFailed", {
+        message: error.message
+      }), []));
+    });
+  }
+  setupCancellationHandler(childProcess, cancellationToken, resolve) {
+    if (!cancellationToken)
+      return;
+    cancellationToken.addEventListener("abort", () => {
+      this.logger.warn(translate2.t("toolWorkflowcompiler.lifecycle.cancelled"));
+      childProcess.kill("SIGTERM");
+      resolve(new ToolResult(ToolErrorCodes.Canceled, translate2.t("toolWorkflowcompiler.errors.operationCancelled"), []));
+    });
+  }
+  parseOutputEntry(line) {
+    try {
+      const parsed = JSON.parse(line);
+      const camelCased = camelCaseKeys(parsed);
+      if (camelCased.errorCode !== undefined) {
+        if (camelCased.errorCode === 0 || camelCased.success === true) {
+          camelCased.errorCode = ToolErrorCodes.Success;
+        } else {
+          camelCased.errorCode = String(camelCased.errorCode);
+        }
+      }
+      if (camelCased.outputPackages) {
+        camelCased.outputPackages = camelCased.outputPackages.map((pkg) => pkg.path || pkg);
+      }
+      return camelCased;
+    } catch {
+      return null;
+    }
+  }
+}
+
+// src/workflow-compiler-tool.ts
+class WorkflowCompilerTool extends ProjectTool {
+  executor;
+  constructor(fileSystem, logger) {
+    super(fileSystem, logger);
+    this.executor = new WorkflowCompilerExecutor(logger, fileSystem);
+  }
+  async restoreAsync(options, cancellationToken) {
+    const args = [
+      `-p`,
+      options.projectPath,
+      `--log-level`,
+      String(options.logLevel ?? LogLevel.Info),
+      `--destination`,
+      options.outputPath ?? "",
+      `--format-logs`,
+      `true`,
+      `--exclude-configured-sources`,
+      `${options.excludeConfiguredSources}`
+    ];
+    if (options.nuGetSourcesConfigPath) {
+      args.push(`--nuget-config-file`, options.nuGetSourcesConfigPath);
+    }
+    return this.executor.executeAsync("restore", args, cancellationToken);
+  }
+  async validateAsync(options, cancellationToken) {
+    const args = [
+      `-p`,
+      options.projectPath,
+      `--log-level`,
+      String(options.logLevel ?? LogLevel.Info),
+      `--format-logs`,
+      `true`,
+      `--skip-analyze`,
+      `${options.skipAnalyze}`,
+      `--exclude-configured-sources`,
+      `${options.excludeConfiguredSources}`
+    ];
+    if (options.detailedLogPath) {
+      args.push(`--detailed`, options.detailedLogPath);
+    }
+    if (options.defaultSeverity) {
+      args.push(`--default-severity`, options.defaultSeverity);
+    }
+    if (options.policyFilePath) {
+      args.push(`--policy-file`, options.policyFilePath);
+    }
+    if (options.policyFileType) {
+      args.push(`--policy-file-type`, `${options.policyFileType}`);
+    }
+    if (options.nuGetSourcesConfigPath) {
+      args.push(`--nuget-config-file`, options.nuGetSourcesConfigPath);
+    }
+    return this.executor.executeAsync("validate", args, cancellationToken);
+  }
+  async buildAsync(options, cancellationToken) {
+    const args = [
+      `-p`,
+      options.projectPath,
+      `-o`,
+      options.outputPath,
+      `--log-level`,
+      String(options.logLevel ?? LogLevel.Info),
+      `--format-logs`,
+      `true`,
+      `--skip-analyze`,
+      `${options.skipAnalyze}`,
+      `--skip-validate`,
+      `${options.skipValidate}`,
+      `--exclude-configured-sources`,
+      `${options.excludeConfiguredSources}`
+    ];
+    if (options.detailedLogPath) {
+      args.push(`--detailed`, options.detailedLogPath);
+    }
+    if (options.policyFilePath) {
+      args.push(`--policy-file`, options.policyFilePath);
+    }
+    if (options.policyFileType) {
+      args.push(`--policy-file-type`, `${options.policyFileType}`);
+    }
+    if (options.outputType) {
+      const outputType = this.mapOutputType(options.outputType);
+      args.push(`--output-type`, outputType);
+    }
+    if (options.nuGetSourcesConfigPath) {
+      args.push(`--nuget-config-file`, options.nuGetSourcesConfigPath);
+    }
+    return this.executor.executeAsync("build", args, cancellationToken);
+  }
+  async packAsync(options, cancellationToken) {
+    const args = [
+      `-p`,
+      options.projectPath,
+      `-o`,
+      options.outputPath,
+      `--build-version`,
+      options.package.version,
+      `--log-level`,
+      String(options.logLevel ?? LogLevel.Info),
+      `--format-logs`,
+      `true`,
+      `--skip-analyze`,
+      `${options.skipAnalyze}`,
+      `--skip-validate`,
+      `${options.skipValidate}`,
+      `--no-optimize-deps`,
+      `${options.skipDependencyOptimization}`,
+      `--include-sources`,
+      `${options.includeSources}`,
+      `--split-packages`,
+      `${options.splitPackages}`,
+      `--exclude-configured-sources`,
+      `${options.excludeConfiguredSources}`,
+      `--pack-options`,
+      JSON.stringify(options.package)
+    ];
+    if (options.package.id) {
+      args.push(`--package-name`, options.package.id);
+    }
+    if (options.detailedLogPath) {
+      args.push(`--detailed`, options.detailedLogPath);
+    }
+    if (options.policyFilePath) {
+      args.push(`--policy-file`, options.policyFilePath);
+    }
+    if (options.policyFileType) {
+      args.push(`--policy-file-type`, options.policyFileType);
+    }
+    if (options.outputType) {
+      const outputType = this.mapOutputType(options.outputType);
+      args.push(`--output-type`, outputType);
+    }
+    if (options.nuGetSourcesConfigPath) {
+      args.push(`--nuget-config-file`, options.nuGetSourcesConfigPath);
+    }
+    return this.executor.executeAsync("build", args, cancellationToken);
+  }
+  mapOutputType(outputType) {
+    return outputType === "WebApp" ? "Process" : outputType;
+  }
+}
+
+// src/workflow-compiler-tool-factory.ts
+class WorkflowCompilerToolFactory {
+  supportedTypes = [
+    ProjectTypes.Process,
+    ProjectTypes.Library,
+    ProjectTypes.Tests,
+    ProjectTypes.WebApp
+  ];
+  async createAsync(logger, fileSystem) {
+    return new WorkflowCompilerTool(fileSystem, logger);
+  }
+}
+
+// src/index.ts
+toolsFactoryRepository.registerProjectToolFactory(new WorkflowCompilerToolFactory);
+export {
+  setupWorkflowCompiler
+};