@uipath/case-tool 1.205.0-preview.281 → 1.206.0-preview.282

package/dist/{packager-tool-yn7r7zq2.js → packager-tool-snesn0bt.js}

@@ -1,6 +1,31 @@
 import {
   zipSync
-} from "./packager-tool-b098y4a2.js";
+} from "./packager-tool-wbksf242.js";
+
+// ../packager/packager-core/src/services/json-object.ts
+function parseJsonObject(text) {
+  if (!text)
+    return;
+  try {
+    const value = JSON.parse(text);
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}
+async function readJsonObjectFile(fs, filePath) {
+  let content;
+  try {
+    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/filesystem/path.ts
 class Path {
@@ -64,26 +89,6 @@ var PROJECT_FILE = "project.json";
 function isNonEmptyString(value) {
   return typeof value === "string" && value.length > 0;
 }
-async function readJsonObject(fs, filePath) {
-  let content;
-  try {
-    content = await fs.readFile(filePath, "utf-8");
-  } catch {
-    return;
-  }
-  if (content === null) {
-    return;
-  }
-  try {
-    const parsed = JSON.parse(content);
-    if (parsed === null || typeof parsed !== "object") {
-      return;
-    }
-    return parsed;
-  } catch {
-    return;
-  }
-}
 async function writeJsonObject(fs, filePath, data) {
   await fs.writeFile(filePath, `${JSON.stringify(data, null, 2)}
 `);
@@ -92,7 +97,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;
     }
@@ -109,7 +114,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;
     }
@@ -129,7 +134,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;
   }
@@ -149,6 +154,152 @@ async function writeOrBackfillOperateProjectId(operateFilePath, projectId, fs, c
   await createIfMissing();
 }
 
+// ../packager/packager-core/src/models/nuget-constants.ts
+var NugetConstants = {
+  OutputFolderName: "bundle",
+  ContentFolderName: "content",
+  OperateFileName: "operate.json",
+  EntryPointsFileName: "entry-points.json",
+  PackageDescriptorFileName: "package-descriptor.json",
+  BindingsV2FileName: "bindings_v2.json",
+  BindingsFileId: "bindings.json"
+};
+
+// ../packager/packager-core/src/services/content-operate-file.ts
+var OPERATE_SCHEMA = "https://cloud.uipath.com/draft/2024-12/operate";
+function withoutContentPrefix(filePath) {
+  return filePath.replace(/^\/?content\//, "");
+}
+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 resolvePackagedMainEntry(entryPoints, operateMain, mainFile) {
+  const named = typeof operateMain === "string" && operateMain !== "" && !entryPoints.some(isDefaultEntryPoint) ? entryPoints.find((entry) => hasFilePath(entry) && withoutContentPrefix(entry.filePath) === withoutContentPrefix(operateMain)) : undefined;
+  return named ?? resolveOperateMainEntry(entryPoints, mainFile);
+}
+function resolvePackagedMain(entryPoints, operateMain, mainFile) {
+  const main = resolvePackagedMainEntry(entryPoints, operateMain, mainFile);
+  return main && hasFilePath(main) ? main.filePath : "";
+}
+function resolveOperateMain(entryPoints, mainFile) {
+  const main = resolveOperateMainEntry(entryPoints, mainFile);
+  return main && hasFilePath(main) ? main.filePath : "";
+}
+function orderDefaultEntryPointFirst(entryPoints, mainFile) {
+  if (!entryPoints.some(isDefaultEntryPoint))
+    return entryPoints;
+  const main = resolveOperateMainEntry(entryPoints, mainFile);
+  return main === undefined ? entryPoints : [main, ...entryPoints.filter((entry) => entry !== main)];
+}
+async function resolveEntryPointMain(fs, sourceFolder, mainFile) {
+  const entryPointsFilePath = Path.join(sourceFolder, NugetConstants.EntryPointsFileName);
+  if (!await fs.exists(entryPointsFilePath)) {
+    return "";
+  }
+  const content = await fs.readFile(entryPointsFilePath);
+  if (!content) {
+    return "";
+  }
+  try {
+    const parsed = JSON.parse(new TextDecoder().decode(content));
+    return resolveOperateMain(parsed.entryPoints ?? [], mainFile);
+  } catch {
+    return "";
+  }
+}
+async function readProjectMainFile(fs, projectDir) {
+  const mainFile = (await readJsonObjectFile(fs, Path.join(projectDir, "project.uiproj")))?.value.MainFile;
+  return typeof mainFile === "string" && mainFile !== "" ? mainFile : undefined;
+}
+async function readOperateMain(fs, folder) {
+  return (await readJsonObjectFile(fs, Path.join(folder, NugetConstants.OperateFileName)))?.value.main;
+}
+function formatLike(original, value) {
+  const eol = original.includes(`\r
+`) ? `\r
+` : `
+`;
+  const minified = !original.trimEnd().includes(`
+`);
+  const indent = /\n([ \t]+)"/.exec(original)?.[1] ?? 2;
+  const text = (minified ? JSON.stringify(value) : JSON.stringify(value, null, indent)).replace(/\n/g, eol);
+  return original.endsWith(`
+`) ? `${text}${eol}` : text;
+}
+async function applyDefaultEntryPoint(fs, params) {
+  const entryPointsPath = Path.join(params.contentFolder, NugetConstants.EntryPointsFileName);
+  const entryPointsFile = await readJsonObjectFile(fs, entryPointsPath);
+  const entryPoints = entryPointsFile?.value.entryPoints;
+  if (!entryPointsFile || !Array.isArray(entryPoints))
+    return;
+  const written = entryPoints.filter((entry) => typeof entry === "object" && entry !== null);
+  if (written.length !== entryPoints.length)
+    return;
+  const entries = params.withDefaults?.(written) ?? written;
+  const ordered = orderDefaultEntryPointFirst(entries, params.mainFile);
+  if (ordered === entries)
+    return;
+  const packaged = ordered.map((entry, index) => {
+    const { isDefault: _isDefault, ...rest } = entry;
+    return index === 0 ? { ...rest, isDefault: true } : rest;
+  });
+  if (JSON.stringify(packaged) !== JSON.stringify(written)) {
+    await fs.writeFile(entryPointsPath, formatLike(entryPointsFile.text, {
+      ...entryPointsFile.value,
+      entryPoints: packaged
+    }));
+  }
+  const main = resolveOperateMain(entries, params.mainFile);
+  const operatePath = Path.join(params.contentFolder, NugetConstants.OperateFileName);
+  const operate = await readJsonObjectFile(fs, operatePath);
+  if (operate && operate.value.main !== main) {
+    await fs.writeFile(operatePath, formatLike(operate.text, { ...operate.value, main }));
+  }
+}
+async function writeContentOperateFile(fs, params) {
+  const operateFilePath = Path.join(params.contentFolder, NugetConstants.OperateFileName);
+  await writeOrBackfillOperateProjectId(operateFilePath, params.projectId, fs, async () => {
+    const main = await resolveEntryPointMain(fs, params.contentFolder, params.mainFile);
+    const operateFileModel = {
+      $schema: OPERATE_SCHEMA,
+      contentType: params.contentType,
+      projectId: params.projectId,
+      main,
+      targetFramework: "Portable",
+      runtimeOptions: {
+        isAttended: false,
+        requiresUserInteraction: false
+      }
+    };
+    await fs.writeFile(operateFilePath, JSON.stringify(operateFileModel, null, 2));
+  });
+}
+async function ensureContentOperateFile(fs, params) {
+  const projectId = params.projectStorageId ?? await ensureProjectId(params.projectPath, fs);
+  await writeContentOperateFile(fs, {
+    contentFolder: params.contentFolder,
+    projectId,
+    contentType: params.contentType,
+    mainFile: params.mainFile
+  });
+}
+
 // ../packager/packager-core/src/services/nuget-packager.ts
 function escapeXml(str) {
   if (str === null || str === undefined) {
@@ -315,76 +466,6 @@ if (!_global[REGISTRY_KEY]) {
   _global[REGISTRY_KEY] = new ToolsFactoryRepository;
 }
 var toolsFactoryRepository = _global[REGISTRY_KEY];
-
-// ../packager/packager-core/src/models/nuget-constants.ts
-var NugetConstants = {
-  OutputFolderName: "bundle",
-  ContentFolderName: "content",
-  OperateFileName: "operate.json",
-  EntryPointsFileName: "entry-points.json",
-  PackageDescriptorFileName: "package-descriptor.json",
-  BindingsV2FileName: "bindings_v2.json",
-  BindingsFileId: "bindings.json"
-};
-
-// ../packager/packager-core/src/services/content-operate-file.ts
-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 ?? "";
-}
-async function resolveEntryPointMain(fs, sourceFolder, mainFile) {
-  const entryPointsFilePath = Path.join(sourceFolder, NugetConstants.EntryPointsFileName);
-  if (!await fs.exists(entryPointsFilePath)) {
-    return "";
-  }
-  const content = await fs.readFile(entryPointsFilePath);
-  if (!content) {
-    return "";
-  }
-  try {
-    const parsed = JSON.parse(new TextDecoder().decode(content));
-    return pickMain(parsed.entryPoints ?? [], mainFile);
-  } catch {
-    return "";
-  }
-}
-async function writeContentOperateFile(fs, params) {
-  const operateFilePath = Path.join(params.contentFolder, NugetConstants.OperateFileName);
-  await writeOrBackfillOperateProjectId(operateFilePath, params.projectId, fs, async () => {
-    const main = await resolveEntryPointMain(fs, params.contentFolder, params.mainFile);
-    const operateFileModel = {
-      $schema: OPERATE_SCHEMA,
-      contentType: params.contentType,
-      projectId: params.projectId,
-      main,
-      targetFramework: "Portable",
-      runtimeOptions: {
-        isAttended: false,
-        requiresUserInteraction: false
-      }
-    };
-    await fs.writeFile(operateFilePath, JSON.stringify(operateFileModel, null, 2));
-  });
-}
-async function ensureContentOperateFile(fs, params) {
-  const projectId = params.projectStorageId ?? await ensureProjectId(params.projectPath, fs);
-  await writeContentOperateFile(fs, {
-    contentFolder: params.contentFolder,
-    projectId,
-    contentType: params.contentType,
-    mainFile: params.mainFile
-  });
-}
 // ../packager/packager-core/src/models/tool-result.ts
 class ToolResult {
   errorCode;
@@ -1321,6 +1402,6 @@ I18nManager.registerTranslations("zh-cn", zh_CN);
 I18nManager.registerTranslations("zh-tw", zh_TW);
 I18nManager.registerTranslations("zu", zu);
 I18nManager.setLocale("en");
-export { Path, TemporaryStorageService, NugetConstants, ToolResult, ensureProjectId, ensureContentOperateFile, NugetPackager, ProjectTool, toolsFactoryRepository };
+export { Path, TemporaryStorageService, NugetConstants, ToolResult, parseJsonObject, readJsonObjectFile, ensureProjectId, isDefaultFlag, resolvePackagedMainEntry, resolvePackagedMain, orderDefaultEntryPointFirst, readProjectMainFile, readOperateMain, applyDefaultEntryPoint, ensureContentOperateFile, NugetPackager, ProjectTool, toolsFactoryRepository };
 
-//# debugId=9474EB3CE7FEFB6964756E2164756E21
+//# debugId=385A56DC6E62528864756E2164756E21

package/dist/{packager-tool-d8e2mrkq.js → packager-tool-tgehy324.js}

@@ -1,21 +1,21 @@
 import {
-  extractIOFromEntryPoints,
-  getServiceType,
-  taskDefinitionsToNodeManifests,
-  withErrorHandles
-} from "./packager-tool-8ftat1vn.js";
+  getFileSystem2
+} from "./packager-tool-z070caqq.js";
 import {
-  catchError,
+  catchError2,
   logger,
   quoteForShell
-} from "./packager-tool-83v804p7.js";
+} from "./packager-tool-psmb758n.js";
 import {
-  getFileSystem
-} from "./packager-tool-hdxtgckw.js";
+  getServiceType,
+  extractIOFromEntryPoints,
+  taskDefinitionsToNodeManifests,
+  withErrorHandles
+} from "./packager-tool-17b466mr.js";
 
 // ../maestro-sdk/src/registry/agent-metadata-reader.ts
 var agentProjectMetadataReader;
-function setAgentProjectMetadataReader(reader) {
+function setAgentProjectMetadataReader2(reader) {
   agentProjectMetadataReader = reader;
 }
 function getAgentProjectMetadataReader() {
@@ -31,7 +31,7 @@ var EMPTY_IO = {
   outputs: {}
 };
 function findEnclosingProjectId(solutionDir, projects, cwd) {
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   for (const p of projects) {
     const projDir = fs.path.resolve(solutionDir, fs.path.dirname(p.ProjectRelativePath));
     if (cwd === projDir)
@@ -43,24 +43,24 @@ function findEnclosingProjectId(solutionDir, projects, cwd) {
   }
   return;
 }
-function solutionSearchDirs() {
-  const fs = getFileSystem();
+function solutionSearchDirs2() {
+  const fs = getFileSystem2();
   const cwd = fs.env.cwd();
   return [cwd, fs.path.resolve(cwd, ".."), fs.path.resolve(cwd, "../..")];
 }
-async function readSolutionAt(dir) {
-  const fs = getFileSystem();
-  const [readErr, entries] = await catchError(fs.readdir(dir));
+async function readSolutionAt2(dir) {
+  const fs = getFileSystem2();
+  const [readErr, entries] = await catchError2(fs.readdir(dir));
   if (readErr)
     return null;
   const uipxName = entries.find((e) => e.endsWith(".uipx"));
   if (!uipxName)
     return null;
   const uipxPath = fs.path.join(dir, uipxName);
-  const [fileErr, content] = await catchError(fs.readFile(uipxPath, "utf-8"));
+  const [fileErr, content] = await catchError2(fs.readFile(uipxPath, "utf-8"));
   if (fileErr || !content)
     return null;
-  const [parseErr, parsed] = catchError(() => JSON.parse(content));
+  const [parseErr, parsed] = catchError2(() => JSON.parse(content));
   if (parseErr || !parsed.SolutionId)
     return null;
   return {
@@ -69,10 +69,10 @@ async function readSolutionAt(dir) {
     projects: parsed.Projects ?? []
   };
 }
-async function findSolutionFromCwd() {
-  const cwd = getFileSystem().env.cwd();
-  for (const dir of solutionSearchDirs()) {
-    const solution = await readSolutionAt(dir);
+async function findSolutionFromCwd2() {
+  const cwd = getFileSystem2().env.cwd();
+  for (const dir of solutionSearchDirs2()) {
+    const solution = await readSolutionAt2(dir);
     if (solution === null)
       continue;
     return {
@@ -82,8 +82,8 @@ async function findSolutionFromCwd() {
   }
   return null;
 }
-async function resolveProjectEntryPointIO(projectDir) {
-  const fs = getFileSystem();
+async function resolveProjectEntryPointIO2(projectDir) {
+  const fs = getFileSystem2();
   const fromSource = await readEntryPointsFile(fs.path.join(projectDir, "entry-points.json"), fs.path.join(projectDir, "content", "entry-points.json"));
   if (fromSource.io)
     return { io: fromSource.io, contract: "known" };
@@ -98,13 +98,13 @@ async function resolveProjectEntryPointIO(projectDir) {
   return { io: EMPTY_IO, contract };
 }
 async function readEntryPointsFile(...candidates) {
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   let state = "absent";
   for (const filePath of candidates) {
-    const [err, content] = await catchError(fs.readFile(filePath, "utf-8"));
+    const [err, content] = await catchError2(fs.readFile(filePath, "utf-8"));
     if (err || content === null)
       continue;
-    const [parseErr, parsed] = catchError(() => JSON.parse(content));
+    const [parseErr, parsed] = catchError2(() => JSON.parse(content));
     const entryPoints = parsed?.entryPoints;
     if (parseErr || !Array.isArray(entryPoints) || entryPoints.length > 0 && !isRecord(entryPoints[0])) {
       if (state === "absent")
@@ -119,18 +119,18 @@ async function readEntryPointsFile(...candidates) {
   return { state };
 }
 async function readProjectIOFromFlowVariables(projectDir) {
-  const fs = getFileSystem();
-  const [readErr, entries] = await catchError(fs.readdir(projectDir));
+  const fs = getFileSystem2();
+  const [readErr, entries] = await catchError2(fs.readdir(projectDir));
   if (readErr || !Array.isArray(entries))
     return { state: "absent" };
   const flowFileName = entries.find((entry) => entry.endsWith(".flow"));
   if (!flowFileName)
     return { state: "absent" };
   const flowPath = fs.path.join(projectDir, flowFileName);
-  const [readFileErr, content] = await catchError(fs.readFile(flowPath, "utf-8"));
+  const [readFileErr, content] = await catchError2(fs.readFile(flowPath, "utf-8"));
   if (readFileErr || !content)
     return { state: "invalid" };
-  const [parseErr, parsed] = catchError(() => JSON.parse(content));
+  const [parseErr, parsed] = catchError2(() => JSON.parse(content));
   if (parseErr || !isRecord(parsed))
     return { state: "invalid" };
   const variables = parsed.variables;
@@ -175,37 +175,37 @@ async function readProjectIOFromFlowVariables(projectDir) {
   return { io: extractIOFromEntryPoints(synthetic), state: "valid" };
 }
 async function readProjectName(projectDir) {
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   const uiprojPath = fs.path.join(projectDir, "project.uiproj");
-  const [err, content] = await catchError(fs.readFile(uiprojPath, "utf-8"));
+  const [err, content] = await catchError2(fs.readFile(uiprojPath, "utf-8"));
   if (!err && content) {
-    const [parseErr, parsed] = catchError(() => JSON.parse(content));
+    const [parseErr, parsed] = catchError2(() => JSON.parse(content));
     if (!parseErr && isRecord(parsed) && typeof parsed.Name === "string" && parsed.Name.length > 0) {
       return parsed.Name;
     }
   }
   return fs.path.basename(projectDir);
 }
-async function loadResourceKeyMap(solutionDir) {
-  const fs = getFileSystem();
+async function loadResourceKeyMap2(solutionDir) {
+  const fs = getFileSystem2();
   const map = new Map;
   const processDir = fs.path.join(solutionDir, "resources", "solution_folder", "process");
-  const [dirErr, typeDirs] = await catchError(fs.readdir(processDir));
+  const [dirErr, typeDirs] = await catchError2(fs.readdir(processDir));
   if (dirErr)
     return map;
   for (const typeDir of typeDirs) {
     const typePath = fs.path.join(processDir, typeDir);
-    const [filesErr, files] = await catchError(fs.readdir(typePath));
+    const [filesErr, files] = await catchError2(fs.readdir(typePath));
     if (filesErr)
       continue;
     for (const file of files) {
       if (!file.endsWith(".json"))
         continue;
       const filePath = fs.path.join(typePath, file);
-      const [readErr, content] = await catchError(fs.readFile(filePath, "utf-8"));
+      const [readErr, content] = await catchError2(fs.readFile(filePath, "utf-8"));
       if (readErr || !content)
         continue;
-      const [parseErr, parsed] = catchError(() => JSON.parse(content));
+      const [parseErr, parsed] = catchError2(() => JSON.parse(content));
       if (parseErr || !isRecord(parsed))
         continue;
       const resource = parsed.resource;
@@ -221,7 +221,7 @@ async function loadResourceKeyMap(solutionDir) {
   return map;
 }
 function invokableSiblings(ctx) {
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   const currentId = ctx.currentProjectId?.toLowerCase();
   return ctx.projects.flatMap((project) => {
     const serviceType = getServiceType(project.Type);
@@ -235,10 +235,10 @@ function invokableSiblings(ctx) {
     return [{ project, serviceType, projectDir }];
   });
 }
-async function buildInSolutionNodes(ctx) {
+async function buildInSolutionNodes2(ctx) {
   const manifests = [];
   const unknownContracts = [];
-  const resourceKeyMap = await loadResourceKeyMap(ctx.solutionDir);
+  const resourceKeyMap = await loadResourceKeyMap2(ctx.solutionDir);
   for (const { project, serviceType, projectDir } of invokableSiblings(ctx)) {
     const resourceKey = resourceKeyMap.get(project.Id.toLowerCase());
     if (!resourceKey)
@@ -246,7 +246,7 @@ async function buildInSolutionNodes(ctx) {
     const reader = getAgentProjectMetadataReader();
     const [name, { io, contract }, projectMetadata] = await Promise.all([
       readProjectName(projectDir),
-      resolveProjectEntryPointIO(projectDir),
+      resolveProjectEntryPointIO2(projectDir),
       reader ? reader(projectDir, project.Type).catch((err) => {
         logger.debug(`Agent metadata reader failed for ${projectDir}: ${String(err)}`);
         return {};
@@ -283,7 +283,7 @@ async function buildInSolutionNodes(ctx) {
   }
   return { manifests: withErrorHandles(manifests), unknownContracts };
 }
-function unknownContractWarning(projects) {
+function unknownContractWarning2(projects) {
   if (projects.length === 0)
     return;
   const describe = (p) => `'${p.name}' (${p.type}, ${p.projectDir}): ${p.contract === "missing" ? "no entry-points.json yet" : "its entry-points.json or .flow file could not be read"}`;
@@ -296,40 +296,40 @@ function unknownContractWarning(projects) {
   const next = steps.join(", and ");
   return `No usable argument contract for ${projects.map(describe).join("; ")}. ` + `${one ? "Its node shows" : "Their nodes show"} no inputs or outputs; the arguments are unknown, not empty. ` + `${next[0].toUpperCase()}${next.slice(1)}, then run this command again.`;
 }
-async function findProjectsWithoutProcessResource(ctx) {
-  const resourceKeyMap = await loadResourceKeyMap(ctx.solutionDir);
+async function findProjectsWithoutProcessResource2(ctx) {
+  const resourceKeyMap = await loadResourceKeyMap2(ctx.solutionDir);
   return Promise.all(invokableSiblings(ctx).filter(({ project }) => !resourceKeyMap.has(project.Id.toLowerCase())).map(async ({ project, projectDir }) => ({
     id: project.Id,
     name: await readProjectName(projectDir),
     type: project.Type
   })));
 }
-function describeProjectsWithoutProcessResource(projects, solutionDir) {
+function describeProjectsWithoutProcessResource2(projects, solutionDir) {
   if (projects.length === 0)
     return {};
   const names = projects.map((p) => `${p.name} (${p.type})`).join(", ");
   return {
     Warning: projects.length === 1 ? `Left out 1 project that has no process resource yet: ${names}.` : `Left out ${projects.length} projects that have no process resource yet: ${names}.`,
-    Instructions: `Create the missing process resources, then list the in-solution nodes again to get their node types. Run: ${resourcesRefreshCommand(solutionDir)}`
+    Instructions: `Create the missing process resources, then list the in-solution nodes again to get their node types. Run: ${resourcesRefreshCommand2(solutionDir)}`
   };
 }
-async function explainNodeTypeWithoutProcessResource(nodeType) {
-  const ctx = await findSolutionFromCwd();
+async function explainNodeTypeWithoutProcessResource2(nodeType) {
+  const ctx = await findSolutionFromCwd2();
   if (!ctx)
     return;
   const lowerNodeType = nodeType.toLowerCase();
-  const project = (await findProjectsWithoutProcessResource(ctx)).find((p) => lowerNodeType.endsWith(`.${p.id.toLowerCase()}`));
+  const project = (await findProjectsWithoutProcessResource2(ctx)).find((p) => lowerNodeType.endsWith(`.${p.id.toLowerCase()}`));
   if (!project)
     return;
   return {
     message: `Project '${project.name}' has no process resource yet, so it has no node type.`,
-    instructions: `Create its process resource, then list the in-solution nodes to get its node type. Run: ${resourcesRefreshCommand(ctx.solutionDir)}`
+    instructions: `Create its process resource, then list the in-solution nodes to get its node type. Run: ${resourcesRefreshCommand2(ctx.solutionDir)}`
   };
 }
-function resourcesRefreshCommand(solutionDir) {
+function resourcesRefreshCommand2(solutionDir) {
   return `uip solution resources refresh --solution-folder ${quoteForShell(solutionDir)}`;
 }
 
-export { setAgentProjectMetadataReader, solutionSearchDirs, readSolutionAt, findSolutionFromCwd, resolveProjectEntryPointIO, loadResourceKeyMap, buildInSolutionNodes, unknownContractWarning, findProjectsWithoutProcessResource, describeProjectsWithoutProcessResource, explainNodeTypeWithoutProcessResource, resourcesRefreshCommand };
+export { setAgentProjectMetadataReader2, solutionSearchDirs2, readSolutionAt2, findSolutionFromCwd2, resolveProjectEntryPointIO2, loadResourceKeyMap2, buildInSolutionNodes2, unknownContractWarning2, findProjectsWithoutProcessResource2, describeProjectsWithoutProcessResource2, explainNodeTypeWithoutProcessResource2, resourcesRefreshCommand2 };
 
-//# debugId=C0E01C7FA4AA2D1564756E2164756E21
+//# debugId=582087DEF1EBB83764756E2164756E21

package/dist/{packager-tool-tqn0j6f9.js → packager-tool-v11fx4dk.js}

@@ -1,8 +1,8 @@
 import {
-  buildExtractDocumentBuilderNode,
+  ootbNodes,
   inlineAgentNodes,
-  ootbNodes
-} from "./packager-tool-8ftat1vn.js";
+  buildExtractDocumentBuilderNode
+} from "./packager-tool-17b466mr.js";
 
 // ../maestro-sdk/src/registry/known-types.ts
 var KNOWN_SDK_NODES = [
@@ -11,15 +11,15 @@ var KNOWN_SDK_NODES = [
   buildExtractDocumentBuilderNode()
 ];
 var KNOWN_SDK_NODE_TYPES = new Set(KNOWN_SDK_NODES.map((n) => n.nodeType.toLowerCase()).filter((t) => typeof t === "string" && t.length > 0));
-function isKnownSdkNodeType(nodeType) {
+function isKnownSdkNodeType2(nodeType) {
   if (typeof nodeType !== "string" || nodeType.length === 0)
     return false;
   return KNOWN_SDK_NODE_TYPES.has(nodeType.toLowerCase());
 }
-function listKnownSdkNodes() {
+function listKnownSdkNodes2() {
   return KNOWN_SDK_NODES.slice();
 }
 
-export { isKnownSdkNodeType, listKnownSdkNodes };
+export { isKnownSdkNodeType2, listKnownSdkNodes2 };
 
-//# debugId=901A5E5E6810517E64756E2164756E21
+//# debugId=AA44820AC8C7293D64756E2164756E21