@uipath/flow-tool 1.205.0-preview.276 → 1.206.0-preview.279

package/dist/{packager-tool-3m4ve01f.js → packager-tool-ryds9860.js}

@@ -1,41 +1,38 @@
 import {
-  writeFlowWorkflow
-} from "./packager-tool-htrt75v4.js";
+  getFileSystem
+} from "./packager-tool-vgrswa8p.js";
 import {
-  nodeModuleRegistry
-} from "./packager-tool-9rmaeaww.js";
+  catchError2
+} from "./packager-tool-pxq0bwp0.js";
 import {
-  prepareProjectLocation,
-  tryRegisterProjectInParentSolution
-} from "./packager-tool-8g5931fz.js";
+  createWorkflow2
+} from "./packager-tool-2b0tn4p4.js";
 import {
-  createWorkflow
-} from "./packager-tool-pvhx9e12.js";
+  nodeModuleRegistry
+} from "./packager-tool-gdpw0daf.js";
 import {
-  applyRuntimeProfile,
-  withRuntimeProfile
-} from "./packager-tool-jgfzfqjm.js";
+  writeFlowWorkflow2
+} from "./packager-tool-6jpvvxyb.js";
 import {
-  VALID_PROJECT_NAME_REGEX
-} from "./packager-tool-eypvc2kv.js";
+  prepareProjectLocation2,
+  tryRegisterProjectInParentSolution2
+} from "./packager-tool-em4ppegs.js";
 import {
-  catchError
-} from "./packager-tool-t7ahhaer.js";
+  applyRuntimeProfile2,
+  withRuntimeProfile2
+} from "./packager-tool-14rdgz3c.js";
 import {
-  getFileSystem
-} from "./packager-tool-myhbp761.js";
-import {
-  __require
-} from "./packager-tool-1yh8g550.js";
+  VALID_PROJECT_NAME_REGEX
+} from "./packager-tool-4zt1s51a.js";
 
 // src/services/project-artifacts.ts
 async function ensureProjectArtifacts(args) {
-  const { addProjectArtifactsToSolutionAsync } = await import("./index-1b2je9n2.js");
+  const { addProjectArtifactsToSolutionAsync } = await import("./index-px95xmkg.js");
   return addProjectArtifactsToSolutionAsync(args);
 }
 
 // src/services/flow-init-service.ts
-class FlowInitSdkSourceError extends Error {
+class FlowInitSdkSourceError2 extends Error {
   instructions;
   projectDir;
   flowFile;
@@ -48,24 +45,24 @@ class FlowInitSdkSourceError extends Error {
   }
 }
 var safeMkdir = async (fs, dir) => {
-  const [err] = await catchError(fs.mkdir(dir));
+  const [err] = await catchError2(fs.mkdir(dir));
   if (err && !(("code" in err) && err.code === "EEXIST")) {
     throw err;
   }
 };
-async function flowInitAsync(name, options = {}) {
+async function flowInitAsync2(name, options = {}) {
   if (!VALID_PROJECT_NAME_REGEX.test(name)) {
     throw new Error(`Invalid project name "${name}". Name can only contain letters, numbers, underscores (_), and hyphens (-).`);
   }
   const fs = getFileSystem();
   const baseDir = options.cwd ?? ".";
-  const { checkSdkSource, seedSdkSource, shellQuote } = await import("./flow-init-sdk-source-xvdvkq7d.js");
+  const { checkSdkSource, seedSdkSource, shellQuote } = await import("./flow-init-sdk-source-xnr4bg25.js");
   const sdkPreflight = options.sdkSource === undefined ? undefined : await checkSdkSource(baseDir, options.sdkSource, options.force);
   if (options.sdkSource !== undefined && sdkPreflight === undefined) {
     throw new Error("--sdk-source needs the uip CLI on Node; it is not available in this host.");
   }
-  const { projectDir, autoCreatedSolution } = await prepareProjectLocation(fs, fs.path.resolve(baseDir, name), name, { skipRegistration: options.skipRegistration });
-  const [statError] = await catchError(fs.stat(projectDir));
+  const { projectDir, autoCreatedSolution } = await prepareProjectLocation2(fs, fs.path.resolve(baseDir, name), name, { skipRegistration: options.skipRegistration });
+  const [statError] = await catchError2(fs.stat(projectDir));
   const projectDirExists = !statError;
   if (statError && !(("code" in statError) && (statError.code === "ENOENT" || statError.code === "PathNotFound"))) {
     throw statError;
@@ -79,7 +76,7 @@ async function flowInitAsync(name, options = {}) {
   await safeMkdir(fs, projectDir);
   const triggerManifest = nodeModuleRegistry["core.trigger.manual"].latest;
   const flowId = crypto.randomUUID();
-  const workflow = createWorkflow({
+  const workflow = createWorkflow2({
     id: flowId,
     name,
     triggerManifest
@@ -91,9 +88,9 @@ async function flowInitAsync(name, options = {}) {
   await fs.writeFile(fs.path.join(projectDir, "project.uiproj"), `${JSON.stringify(projectUiproj, null, 2)}
 `);
   const flowFile = fs.path.join(projectDir, `${name}.flow`);
-  await writeFlowWorkflow(flowFile, workflow);
+  await writeFlowWorkflow2(flowFile, workflow);
   const profile = options.profile === "Lite" ? "Lite" /* Lite */ : "Standard" /* Standard */;
-  const operateJson = withRuntimeProfile({
+  const operateJson = withRuntimeProfile2({
     $schema: "https://cloud.uipath.com/draft/2024-12/operate",
     projectId: flowId,
     contentType: "Flow",
@@ -105,8 +102,8 @@ async function flowInitAsync(name, options = {}) {
   }, profile);
   await fs.writeFile(fs.path.join(projectDir, "operate.json"), `${JSON.stringify(operateJson, null, 2)}
 `);
-  await applyRuntimeProfile(fs, projectDir, profile);
-  const registration = await tryRegisterProjectInParentSolution(fs, projectDir, { skipRegistration: options.skipRegistration });
+  await applyRuntimeProfile2(fs, projectDir, profile);
+  const registration = await tryRegisterProjectInParentSolution2(fs, projectDir, { skipRegistration: options.skipRegistration });
   const projectArtifacts = await maybeGenerateProjectArtifacts(registration, name);
   const sdkSourceTarget = sdkPreflight ? sdkPreflight.target ?? fs.path.join(projectDir, ".flow-sdk", `${name}.flow.ts`) : undefined;
   if (sdkSourceTarget) {
@@ -116,7 +113,7 @@ async function flowInitAsync(name, options = {}) {
         message: "the builder SDK is not available in this host",
         instructions: "Run the command from the uip CLI on Node."
       };
-      throw new FlowInitSdkSourceError(`Flow project created at ${projectDir}, but seeding the SDK source failed: ${failure.message}`, `${failure.instructions} Then seed it with: uip maestro flow decompile ${shellQuote(flowFile)} -o ${shellQuote(sdkSourceTarget)} --no-pipeline`, projectDir, flowFile);
+      throw new FlowInitSdkSourceError2(`Flow project created at ${projectDir}, but seeding the SDK source failed: ${failure.message}`, `${failure.instructions} Then seed it with: uip maestro flow decompile ${shellQuote(flowFile)} -o ${shellQuote(sdkSourceTarget)} --no-pipeline`, projectDir, flowFile);
     }
   }
   return {
@@ -142,6 +139,6 @@ async function maybeGenerateProjectArtifacts(registration, projectName) {
   });
 }
 
-export { FlowInitSdkSourceError, flowInitAsync };
+export { FlowInitSdkSourceError2, flowInitAsync2 };
 
-//# debugId=0292FC4545E2835664756E2164756E21
+//# debugId=F1D4FF6BC48DF2EB64756E2164756E21

package/dist/{packager-tool-ykbahxma.js → packager-tool-t17t9svg.js}

@@ -1,13 +1,13 @@
-import {
-  inMemoryWorkflowToFileFormat
-} from "./packager-tool-s7wb0s9n.js";
 import {
   logger
-} from "./packager-tool-apawc11t.js";
+} from "./packager-tool-8ed52y5r.js";
+import {
+  workflowToFileFormat
+} from "./packager-tool-6jpvvxyb.js";
 
 // src/utils/write-resolved-flow.ts
 async function writeResolvedFlow(fs, dir, name, workflow) {
-  const resolvedFileFormat = inMemoryWorkflowToFileFormat(workflow);
+  const resolvedFileFormat = workflowToFileFormat(workflow);
   const resolvedPath = fs.path.join(dir, `${name}.flow.resolved`);
   await fs.writeFile(resolvedPath, JSON.stringify(resolvedFileFormat, null, 2));
   logger.info(`Resolved flow written to ${resolvedPath}`);
@@ -15,4 +15,4 @@ async function writeResolvedFlow(fs, dir, name, workflow) {
 
 export { writeResolvedFlow };
 
-//# debugId=6009258457D2C62464756E2164756E21
+//# debugId=A0D8F1D389833DF464756E2164756E21

package/dist/{packager-tool-myhbp761.js → packager-tool-vgrswa8p.js}

@@ -1,9 +1,5 @@
-import {
-  __require
-} from "./packager-tool-1yh8g550.js";
-
 // ../filesystem/src/node.ts
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
@@ -14,6 +10,9 @@ var LOCK_MAX_WAIT_MS = 20000;
 var LOCK_MAX_HOLD_MS = 60000;
 var LOCK_RETRY_MIN_MS = 100;
 var LOCK_RETRY_JITTER_MS = 200;
+var HASH_CHUNK_BYTES = 256 * 1024;
+var hashBuffers = [];
+var HASH_BUFFERS_KEPT = 64;
 
 class NodeFileSystem {
   path = {
@@ -32,7 +31,7 @@ class NodeFileSystem {
   };
   utils = {
     open: async (url) => {
-      const { default: open } = await import("./index-h8cph72k.js");
+      const { default: open } = await import("./index-nzr4mx5p.js");
       await open(url);
     }
   };
@@ -71,6 +70,15 @@ class NodeFileSystem {
       throw error;
     }
   }
+  async readdirEntries(dirPath) {
+    try {
+      return await fs.readdir(dirPath, { withFileTypes: true });
+    } catch (error) {
+      if (this.isEnoent(error))
+        return [];
+      throw error;
+    }
+  }
   async stat(filePath) {
     try {
       const stats = await fs.stat(filePath);
@@ -78,7 +86,8 @@ class NodeFileSystem {
         isFile: () => stats.isFile(),
         isDirectory: () => stats.isDirectory(),
         size: stats.size,
-        mtimeMs: stats.mtimeMs
+        mtimeMs: stats.mtimeMs,
+        ctimeMs: stats.ctimeMs
       };
     } catch (error) {
       if (this.isEnoent(error))
@@ -192,6 +201,42 @@ class NodeFileSystem {
       throw error;
     }
   }
+  async hashFile(filePath) {
+    let handle;
+    try {
+      handle = await fs.open(filePath, "r");
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+    const buffer = hashBuffers.pop() ?? Buffer.allocUnsafe(HASH_CHUNK_BYTES);
+    try {
+      const opened = await handle.stat();
+      const stats = {
+        isFile: () => opened.isFile(),
+        isDirectory: () => opened.isDirectory(),
+        size: opened.size,
+        mtimeMs: opened.mtimeMs,
+        ctimeMs: opened.ctimeMs
+      };
+      const hash = createHash("sha256");
+      let size = 0;
+      for (;; ) {
+        const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, null);
+        if (bytesRead === 0)
+          break;
+        hash.update(buffer.subarray(0, bytesRead));
+        size += bytesRead;
+      }
+      return { sha256: hash.digest("hex"), size, stats };
+    } finally {
+      if (hashBuffers.length < HASH_BUFFERS_KEPT) {
+        hashBuffers.push(buffer);
+      }
+      await handle.close();
+    }
+  }
   async realpath(filePath) {
     try {
       return await fs.realpath(filePath);
@@ -244,4 +289,4 @@ var getFileSystem = () => fsInstance;
 
 export { NodeFileSystem, getFileSystem };
 
-//# debugId=C097B4FF8DD97C0C64756E2164756E21
+//# debugId=6B0A3304ED8573E564756E2164756E21

package/dist/{packager-tool-7hw344bt.js → packager-tool-xb16e3tz.js}

@@ -1,5 +1,5 @@
 // ../maestro-sdk/src/registry/filter-engine.ts
-function filterNodes(nodes, parsedFilters) {
+function filterNodes2(nodes, parsedFilters) {
   if (!parsedFilters.filters || parsedFilters.filters.length === 0) {
     return nodes;
   }
@@ -70,10 +70,10 @@ function getFieldValue(node, field) {
       return node[field];
   }
 }
-function searchWithFilters(nodes, keyword, filters) {
+function searchWithFilters2(nodes, keyword, filters) {
   let results = nodes;
   if (filters && filters.filters.length > 0) {
-    results = filterNodes(results, filters);
+    results = filterNodes2(results, filters);
   }
   if (keyword && keyword.trim() !== "") {
     const lowerKeyword = keyword.toLowerCase();
@@ -102,6 +102,6 @@ function searchWithFilters(nodes, keyword, filters) {
   return results;
 }
 
-export { filterNodes, searchWithFilters };
+export { filterNodes2, searchWithFilters2 };
 
-//# debugId=625152056CCA62E564756E2164756E21
+//# debugId=A8C2AA775C3F632764756E2164756E21

package/dist/{packager-tool-1frs4sr4.js → packager-tool-yewnsyag.js}

@@ -57,7 +57,7 @@ function deriveHandleCustomizationSourceOverride(node) {
   if (!Array.isArray(groups))
     return null;
   const positions = [];
-  const ids = [];
+  const sourceHandles = [];
   for (const group of groups) {
     if (!group || typeof group !== "object")
       continue;
@@ -73,11 +73,43 @@ function deriveHandleCustomizationSourceOverride(node) {
         continue;
       const h = handle;
       if (h.type === "source" && typeof h.id === "string") {
-        ids.push(h.id);
+        sourceHandles.push({
+          id: h.id,
+          ...typeof h.handleType === "string" ? { handleType: h.handleType } : {}
+        });
       }
     }
   }
-  return ids.length > 0 ? { positions, sourceHandleIds: ids } : null;
+  return sourceHandles.length > 0 ? { positions, sourceHandles } : null;
+}
+function applyInstanceSourceHandles(handles, node, options) {
+  const sourceDeclared = [...handles.source.values()].some((info) => info.position !== undefined) || handles.sourceTemplates.length > 0;
+  if (!sourceDeclared) {
+    return { sourceDeclared, customization: null };
+  }
+  const customization = deriveHandleCustomizationSourceOverride(node);
+  if (!customization) {
+    if (options.deriveOutcomes) {
+      for (const id of deriveOutcomeHandleIds(node)) {
+        if (!handles.source.has(id)) {
+          handles.source.set(id, {});
+        }
+      }
+    }
+    return { sourceDeclared, customization: null };
+  }
+  const replaced = new Set(customization.positions);
+  const isReplaced = (info) => info.position !== undefined && replaced.has(info.position);
+  for (const [id, info] of [...handles.source]) {
+    if (isReplaced(info)) {
+      handles.source.delete(id);
+    }
+  }
+  handles.sourceTemplates = handles.sourceTemplates.filter((template) => !isReplaced(template.info));
+  for (const handle of customization.sourceHandles) {
+    handles.source.set(handle.id, { handleType: handle.handleType });
+  }
+  return { sourceDeclared, customization };
 }
 function expandHandleIds(handle, node) {
   if (!handle.repeat) {
@@ -112,6 +144,6 @@ function portMatchesTemplate(requestedPort, templateId) {
   return pattern.test(requestedPort);
 }
 
-export { ERROR_SOURCE_PORT, enableErrorHandlingForErrorEdges, parseVisibleInputKey, isHandleVisible, deriveOutcomeHandleIds, deriveHandleCustomizationSourceOverride, expandHandleIds, isTemplatedHandleId, portMatchesTemplate };
+export { ERROR_SOURCE_PORT, enableErrorHandlingForErrorEdges, parseVisibleInputKey, isHandleVisible, applyInstanceSourceHandles, expandHandleIds, isTemplatedHandleId, portMatchesTemplate };
 
-//# debugId=338F9DF71F4BCE8C64756E2164756E21
+//# debugId=F9C72DA1BA2E597864756E2164756E21

package/dist/packager-tool-zdqbp34f.js

@@ -0,0 +1,14 @@
+// ../auth/src/utils/platform.ts
+function isBrowser2() {
+  return typeof globalThis !== "undefined" && "window" in globalThis && "document" in globalThis;
+}
+function getGlobalThis() {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  return;
+}
+
+export { isBrowser2, getGlobalThis };
+
+//# debugId=BB900EA7514A888D64756E2164756E21

package/dist/{packager-tool-pacrqxv2.js → packager-tool-ze3fnf3s.js}

@@ -1,7 +1,7 @@
 import {
-  unzipSync,
-  zipSync
-} from "./packager-tool-nkrmjr3a.js";
+  zipSync,
+  unzipSync
+} from "./packager-tool-mphfxa9g.js";
 
 // ../packager/packager-core/src/filesystem/path.ts
 class Path {
@@ -59,31 +59,36 @@ class Path {
   }
 }
 
-// ../packager/packager-core/src/services/project-id.ts
-var OPERATE_FILE = "operate.json";
-var PROJECT_FILE = "project.json";
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.length > 0;
-}
-async function readJsonObject(fs, filePath) {
-  let content;
+// ../packager/packager-core/src/services/json-object.ts
+function parseJsonObject(text) {
+  if (!text)
+    return;
   try {
-    content = await fs.readFile(filePath, "utf-8");
+    const value = JSON.parse(text);
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
   } catch {
     return;
   }
-  if (content === null) {
-    return;
-  }
+}
+async function readJsonObjectFile(fs, filePath) {
+  let content;
   try {
-    const parsed = JSON.parse(content);
-    if (parsed === null || typeof parsed !== "object") {
-      return;
-    }
-    return parsed;
+    content = await fs.readFile(filePath);
   } catch {
     return;
   }
+  if (!content)
+    return;
+  const text = typeof content === "string" ? content : new TextDecoder().decode(content);
+  const value = parseJsonObject(text);
+  return value ? { text, value } : undefined;
+}
+
+// ../packager/packager-core/src/services/project-id.ts
+var OPERATE_FILE = "operate.json";
+var PROJECT_FILE = "project.json";
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
 }
 async function writeJsonObject(fs, filePath, data) {
   await fs.writeFile(filePath, `${JSON.stringify(data, null, 2)}
@@ -93,7 +98,7 @@ async function ensureProjectId(projectPath, fs) {
   const operatePath = Path.join(projectPath, OPERATE_FILE);
   const operateExists = await fs.exists(operatePath);
   if (operateExists) {
-    const operate = await readJsonObject(fs, operatePath);
+    const operate = (await readJsonObjectFile(fs, operatePath))?.value;
     if (operate && isNonEmptyString(operate.projectId)) {
       return operate.projectId;
     }
@@ -110,7 +115,7 @@ async function ensureProjectId(projectPath, fs) {
   const projectFilePath = Path.join(projectPath, PROJECT_FILE);
   const projectFileExists = await fs.exists(projectFilePath);
   if (projectFileExists) {
-    const projectFile = await readJsonObject(fs, projectFilePath);
+    const projectFile = (await readJsonObjectFile(fs, projectFilePath))?.value;
     if (projectFile && isNonEmptyString(projectFile.projectId)) {
       return projectFile.projectId;
     }
@@ -130,7 +135,7 @@ async function ensureProjectIdInOperateFile(operateFilePath, fallbackProjectId,
   if (!await fs.exists(operateFilePath)) {
     return;
   }
-  const parsed = await readJsonObject(fs, operateFilePath);
+  const parsed = (await readJsonObjectFile(fs, operateFilePath))?.value;
   if (!parsed) {
     return;
   }
@@ -213,15 +218,28 @@ var OPERATE_SCHEMA = "https://cloud.uipath.com/draft/2024-12/operate";
 function withoutContentPrefix(filePath) {
   return filePath.replace(/^\/?content\//, "");
 }
-function pickMain(entryPoints, mainFile) {
-  if (mainFile) {
-    const wanted = withoutContentPrefix(mainFile);
-    const declared = entryPoints.find(({ filePath }) => filePath !== undefined && withoutContentPrefix(filePath) === wanted)?.filePath;
-    if (declared) {
-      return declared;
-    }
-  }
-  return entryPoints[0]?.filePath ?? "";
+function entryPointFile(filePath) {
+  const path = withoutContentPrefix(filePath);
+  const file = path.split("#")[0] ?? "";
+  return file.endsWith(".bpmn") ? file : path;
+}
+function hasFilePath(entry) {
+  return typeof entry === "object" && entry !== null && typeof entry.filePath === "string";
+}
+function isDefaultFlag(value) {
+  return value === true || value === "true";
+}
+function isDefaultEntryPoint(entry) {
+  return hasFilePath(entry) && isDefaultFlag(entry.isDefault);
+}
+function resolveOperateMainEntry(entryPoints, mainFile) {
+  const wanted = mainFile ? entryPointFile(mainFile) : undefined;
+  const inMainFile = wanted ? entryPoints.filter((entry) => hasFilePath(entry) && entryPointFile(entry.filePath) === wanted) : [];
+  return inMainFile.find(isDefaultEntryPoint) ?? inMainFile[0] ?? entryPoints.find(isDefaultEntryPoint) ?? entryPoints[0];
+}
+function resolveOperateMain(entryPoints, mainFile) {
+  const main = resolveOperateMainEntry(entryPoints, mainFile);
+  return main && hasFilePath(main) ? main.filePath : "";
 }
 async function resolveEntryPointMain(fs, sourceFolder, mainFile) {
   const entryPointsFilePath = Path.join(sourceFolder, NugetConstants.EntryPointsFileName);
@@ -234,7 +252,7 @@ async function resolveEntryPointMain(fs, sourceFolder, mainFile) {
   }
   try {
     const parsed = JSON.parse(new TextDecoder().decode(content));
-    return pickMain(parsed.entryPoints ?? [], mainFile);
+    return resolveOperateMain(parsed.entryPoints ?? [], mainFile);
   } catch {
     return "";
   }
@@ -1464,4 +1482,4 @@ class LogMessage {
 }
 export { Path, TemporaryStorageService, ZipService, I18nManager, translate, normalizeIgnoredRules, LogMessage, NugetConstants, ToolResult, ensureProjectId, writeContentOperateFile, NugetPackager, ProjectTool, toolsFactoryRepository };
 
-//# debugId=9C27E0A1F2D17B7B64756E2164756E21
+//# debugId=8AB0E4AD43E876BE64756E2164756E21

package/dist/packager-tool.js

@@ -1,36 +1,16 @@
 import {
-  registerPackagerFactories
-} from "./packager-tool-ap0zt7de.js";
-import"./packager-tool-7ja1b5hh.js";
-import"./packager-tool-pvhx9e12.js";
-import"./packager-tool-jgfzfqjm.js";
-import"./packager-tool-dbsdy4xx.js";
-import"./packager-tool-qkn0c042.js";
-import"./packager-tool-pacrqxv2.js";
-import"./packager-tool-nkrmjr3a.js";
-import"./packager-tool-rs6jm14d.js";
-import"./packager-tool-hk1gxnth.js";
-import"./packager-tool-mgcz986r.js";
-import"./packager-tool-xj0agqpk.js";
-import"./packager-tool-pcvhcn2k.js";
-import"./packager-tool-sc961w0q.js";
-import"./packager-tool-t07ev0jj.js";
-import"./packager-tool-7bam8cjq.js";
-import"./packager-tool-gbgfwx8f.js";
-import"./packager-tool-6z1hsm2h.js";
-import"./packager-tool-jysvpt8p.js";
-import"./packager-tool-s7wb0s9n.js";
-import"./packager-tool-p79yh9ww.js";
-import"./packager-tool-jrnjzs5t.js";
-import"./packager-tool-z83pga0z.js";
-import"./packager-tool-6ejqwbw9.js";
-import"./packager-tool-mcaf4ewf.js";
-import"./packager-tool-myhbp761.js";
-import"./packager-tool-4mna26cc.js";
-import"./packager-tool-c23zrhj8.js";
-import"./packager-tool-1yh8g550.js";
+  registerPackagerFactories2
+} from "./packager-tool-99d2kj94.js";
+import"./packager-tool-mdf7bws6.js";
+import"./packager-tool-2b0tn4p4.js";
+import"./packager-tool-14rdgz3c.js";
+import"./packager-tool-jd3v0bh1.js";
+import"./packager-tool-4g87fbz6.js";
+import"./packager-tool-ze3fnf3s.js";
+import"./packager-tool-fzgfb0jt.js";
+import"./packager-tool-vgrswa8p.js";
 export {
-  registerPackagerFactories
+  registerPackagerFactories2 as registerPackagerFactories
 };
 
-//# debugId=3A2977661ABADE8B64756E2164756E21
+//# debugId=EEF000601B9B06FB64756E2164756E21

package/dist/prepare-uip-ad7mfs8t.js

@@ -0,0 +1,92 @@
+// ../builder-sdk/src/prepare-uip.ts
+var PREPARE_COMMANDS = [
+  ["is", "connections", "list"],
+  ["is", "connectors", "metadata"],
+  ["is", "activities", "list"],
+  ["is", "resources", "list"],
+  ["is", "resources", "describe"],
+  ["is", "resources", "run", "list"],
+  ["is", "triggers", "objects"],
+  ["is", "triggers", "describe"],
+  ["maestro", "flow", "registry", "get"],
+  ["maestro", "flow", "registry", "search"],
+  ["maestro", "flow", "registry", "pull"]
+];
+var HOST_GLOBAL_OPTIONS = [
+  "--json",
+  "--log-level",
+  "--log-file",
+  "--profile",
+  "--interactive",
+  "--no-interactive"
+];
+function isPrepareCommand(args) {
+  return PREPARE_COMMANDS.some((words) => words.every((word, index) => args[index] === word));
+}
+function hostGlobalOption(args) {
+  return HOST_GLOBAL_OPTIONS.find((option) => args.some((arg) => arg === option || arg.startsWith(`${option}=`)));
+}
+function refusal(argv) {
+  if (!Array.isArray(argv) || !argv.every((arg) => typeof arg === "string")) {
+    return "uip: argv must be a list of strings";
+  }
+  const [executable, ...args] = argv;
+  if (executable !== "uip" || !isPrepareCommand(args)) {
+    return `uip: ${(executable === "uip" ? args : argv).join(" ")} is not available to registry prepare in this host`;
+  }
+  const option = hostGlobalOption(args);
+  return option === undefined ? undefined : `uip: ${option} is not available to registry prepare in this host`;
+}
+function failed(stderr) {
+  return { code: 1, stdout: "", stderr };
+}
+function timeLimit(timeoutMs) {
+  let timer;
+  let start = () => {};
+  const expired = new Promise((resolve) => {
+    start = () => {
+      timer = setTimeout(() => resolve({
+        code: null,
+        stdout: "",
+        stderr: "",
+        timedOut: true
+      }), timeoutMs);
+    };
+  });
+  return { start, expired, clear: () => clearTimeout(timer) };
+}
+function prepareUip(runInProcess) {
+  const running = new Set;
+  const ended = new AbortController;
+  return {
+    uip: {
+      slot: "uipath.maestro-builder-sdk.uip",
+      run(argv, options = {}) {
+        const refused = ended.signal.aborted ? "uip: registry prepare has ended" : refusal(argv);
+        if (refused !== undefined) {
+          return Promise.resolve(failed(refused));
+        }
+        const { timeoutMs } = options;
+        const limit = timeoutMs === undefined || timeoutMs <= 0 ? undefined : timeLimit(timeoutMs);
+        const answer = runInProcess(argv.slice(1), {
+          signal: ended.signal,
+          onStart: limit?.start
+        }).catch((error) => failed(`uip: ${error instanceof Error ? error.message : String(error)}`));
+        running.add(answer);
+        answer.finally(() => running.delete(answer));
+        return limit ? Promise.race([answer, limit.expired]).finally(limit.clear) : answer;
+      }
+    },
+    close: () => {
+      ended.abort(new Error("registry prepare has ended"));
+    },
+    settled: async () => {
+      await Promise.all(running);
+    }
+  };
+}
+export {
+  prepareUip
+};
+
+//# debugId=DA8A8649FCF5573C64756E2164756E21