@uipath/flow-tool 1.201.0 → 1.202.0-preview.136

package/dist/packager-tool-e0p2zsyc.js

@@ -0,0 +1,97 @@
+import {
+  en_default
+} from "./packager-tool-a42jnpy5.js";
+import {
+  __glob
+} from "./packager-tool-c23zrhj8.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// ../../node_modules/@uipath/flow-schema/dist/chunk-IUN2JAAB.js
+var SUPPORTED_LOCALES = ["en", "es", "pt", "de", "fr", "ja", "ko", "ru", "tr", "ro", "zh-CN", "zh-TW", "pt-BR", "es-MX"];
+var DEFAULT_LOCALE = "en";
+function normalizeCasing(locale) {
+  const [language, country] = locale.split("-");
+  return country ? `${language}-${country.toUpperCase()}` : language;
+}
+function normalizeLocale(locale) {
+  const cased = normalizeCasing(locale);
+  const supported = SUPPORTED_LOCALES;
+  if (supported.includes(cased))
+    return cased;
+  const base = cased.split("-")[0];
+  if (supported.includes(base))
+    return base;
+  return DEFAULT_LOCALE;
+}
+function resolveSupportedLocale(locale) {
+  const cased = normalizeCasing(locale);
+  const supported = SUPPORTED_LOCALES;
+  if (supported.includes(cased))
+    return cased;
+  const base = cased.split("-")[0];
+  if (supported.includes(base))
+    return base;
+  return null;
+}
+var REGISTERED = /* @__PURE__ */ new WeakMap;
+function createI18nRegistrar(options) {
+  const { namespace, englishBundle, loadCatalog } = options;
+  return (instance) => {
+    let registered = REGISTERED.get(instance);
+    if (registered?.has(namespace))
+      return;
+    if (!registered) {
+      registered = /* @__PURE__ */ new Set;
+      REGISTERED.set(instance, registered);
+    }
+    registered.add(namespace);
+    instance.addResourceBundle("en", namespace, englishBundle, true, true);
+    const loaded = { en: true };
+    const loadForLocale = async (lng) => {
+      const target = resolveSupportedLocale(lng);
+      if (!target || loaded[target])
+        return;
+      try {
+        const mod = await loadCatalog(target);
+        instance.addResourceBundle(target, namespace, mod.default, true, true);
+        loaded[target] = true;
+      } catch (err) {
+        console.warn(`[i18n] Failed to load '${target}' catalog for namespace '${namespace}':`, err);
+      }
+    };
+    instance.on("languageChanged", (lng) => {
+      loadForLocale(lng);
+    });
+    if (instance.language) {
+      loadForLocale(instance.language);
+    }
+  };
+}
+var globImport_locales_json = __glob({
+  "../../locales/de.json": () => import("./de-5KVP66U6-1bnf4zt5.js"),
+  "../../locales/en.json": () => import("./en-X3S6IZ5J-nhkg6pwn.js"),
+  "../../locales/es-MX.json": () => import("./es-MX-XAVLOQW3-q00km2y7.js"),
+  "../../locales/es.json": () => import("./es-VFPNVMP5-bx2c337j.js"),
+  "../../locales/fr.json": () => import("./fr-E5MDO4EG-c3mkty2t.js"),
+  "../../locales/ja.json": () => import("./ja-DPO5PPLO-mysfmznx.js"),
+  "../../locales/ko.json": () => import("./ko-ITOPNIYI-hmxd2asd.js"),
+  "../../locales/pt-BR.json": () => import("./pt-BR-BXURWX4W-bwfcwhk1.js"),
+  "../../locales/pt.json": () => import("./pt-YI4VE4YQ-wdkn2dcf.js"),
+  "../../locales/ro.json": () => import("./ro-RKXZUG7Z-nndrrsq7.js"),
+  "../../locales/ru.json": () => import("./ru-WBLQ5B2U-8r3c7v6d.js"),
+  "../../locales/tr.json": () => import("./tr-AA6O2WSR-86ba4bdf.js"),
+  "../../locales/zh-CN.json": () => import("./zh-CN-R2KLHXQV-agqr45ds.js"),
+  "../../locales/zh-TW.json": () => import("./zh-TW-RJGCQANM-w0x3qc1p.js")
+});
+var VALIDATION_NAMESPACE = "validation";
+var registerFlowSchemaI18n = createI18nRegistrar({
+  namespace: VALIDATION_NAMESPACE,
+  englishBundle: en_default,
+  loadCatalog: (lng) => globImport_locales_json(`../../locales/${lng}.json`)
+});
+
+export { SUPPORTED_LOCALES, DEFAULT_LOCALE, normalizeLocale, resolveSupportedLocale, createI18nRegistrar, VALIDATION_NAMESPACE, registerFlowSchemaI18n };
+
+//# debugId=9CA4D26B4AC47A9264756E2164756E21

package/dist/packager-tool-eebq62fq.js

@@ -0,0 +1,540 @@
+import {
+  catchError,
+  logger,
+  unsupportedSolutionProjectType
+} from "./packager-tool-5qaxht3k.js";
+
+// ../solution-sdk/src/solution-file.ts
+var STUDIO_WEB_PROJECT_TYPE_OVERRIDES = {
+  ProcessOrchestration: "processOrchestration"
+};
+function normalizeProjectType(projectType) {
+  return STUDIO_WEB_PROJECT_TYPE_OVERRIDES[projectType] ?? projectType;
+}
+function toPortableRelativePath(relativePath) {
+  return relativePath.replace(/\\/g, "/");
+}
+async function readUipxFile(fs, solutionDir) {
+  const dirEntries = await fs.readdir(solutionDir);
+  const uipxFileName = dirEntries.find((f) => f.endsWith(".uipx"));
+  if (!uipxFileName) {
+    throw new Error(`No .uipx file found in ${solutionDir}. Run 'uip solution init' first.`);
+  }
+  const uipxContent = await fs.readFile(fs.path.join(solutionDir, uipxFileName), "utf-8");
+  if (!uipxContent) {
+    throw new Error(`Could not read .uipx file: ${uipxFileName} is empty or missing.`);
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(uipxContent));
+  if (parseError) {
+    throw new Error(`Invalid .uipx file: could not parse JSON in ${uipxFileName}.`);
+  }
+  const uipx = validateUipxFile(parsed, uipxFileName);
+  return { uipx, uipxFileName };
+}
+function validateUipxFile(parsed, uipxFileName) {
+  if (!isRecord(parsed)) {
+    throw new Error(`Invalid .uipx file: ${uipxFileName} must contain a JSON object.`);
+  }
+  if (typeof parsed.SolutionId !== "string" || !parsed.SolutionId.trim()) {
+    throw new Error("Invalid .uipx file: missing SolutionId.");
+  }
+  if (!Array.isArray(parsed.Projects) || parsed.Projects.length === 0) {
+    throw new Error("Invalid .uipx file: missing Projects.");
+  }
+  for (const [index, project] of parsed.Projects.entries()) {
+    if (!isRecord(project)) {
+      throw new Error(`Invalid .uipx file: Projects[${index}] must be an object.`);
+    }
+    if (typeof project.ProjectRelativePath !== "string" || !project.ProjectRelativePath.trim()) {
+      const pathHint = typeof project.Path === "string" ? " Found Path, but .uipx uses ProjectRelativePath." : "";
+      throw new Error(`Invalid .uipx file: Projects[${index}] is missing ProjectRelativePath.${pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`);
+    }
+  }
+  return parsed;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function createSolutionManifest(fs, solutionDir, solutionName, options = {}) {
+  const resolvedDir = fs.path.resolve(solutionDir);
+  if (!(options.allowExistingDir && await fs.exists(resolvedDir))) {
+    await fs.mkdir(resolvedDir);
+  }
+  const solutionId = crypto.randomUUID();
+  const manifest = {
+    DocVersion: "1.0.0",
+    StudioMinVersion: "2025.10.0",
+    SolutionId: solutionId,
+    Projects: []
+  };
+  const solutionFile = fs.path.join(resolvedDir, `${solutionName}.uipx`);
+  await fs.writeFile(solutionFile, `${JSON.stringify(manifest, null, 2)}
+`);
+  return {
+    solutionDir: resolvedDir,
+    solutionFile,
+    solutionId
+  };
+}
+var AUTO_SOLUTION_SUFFIX = "Solution";
+async function autoScaffoldSolution(fs, baseDir, projectName) {
+  const solutionName = `${projectName}${AUTO_SOLUTION_SUFFIX}`;
+  const solutionDir = fs.path.resolve(baseDir, solutionName);
+  const expectedSolutionFile = fs.path.join(solutionDir, `${solutionName}.uipx`);
+  if (await fs.exists(expectedSolutionFile)) {
+    return {
+      Name: solutionName,
+      Path: solutionDir,
+      SolutionFile: expectedSolutionFile
+    };
+  }
+  const { solutionFile } = await createSolutionManifest(fs, solutionDir, solutionName, { allowExistingDir: true });
+  return {
+    Name: solutionName,
+    Path: solutionDir,
+    SolutionFile: solutionFile
+  };
+}
+async function prepareProjectLocation(fs, candidateProjectDir, projectName, options = {}) {
+  const resolved = fs.path.resolve(candidateProjectDir);
+  if (options.skipRegistration) {
+    return { projectDir: resolved };
+  }
+  const discovery = await findNearestParentUipxFile(fs, resolved);
+  if (discovery.status !== "notFound") {
+    return { projectDir: resolved };
+  }
+  const baseDir = fs.path.dirname(resolved);
+  const autoCreatedSolution = await autoScaffoldSolution(fs, baseDir, projectName);
+  const projectDir = fs.path.join(autoCreatedSolution.Path, projectName);
+  await warnIfCandidateDirShadowed(fs, resolved, projectDir);
+  return { projectDir, autoCreatedSolution };
+}
+async function warnIfCandidateDirShadowed(fs, candidateDir, projectDir) {
+  const [, exists] = await catchError(fs.exists(candidateDir));
+  if (!exists) {
+    return;
+  }
+  const [, entries] = await catchError(fs.readdir(candidateDir));
+  if (!entries || entries.length === 0) {
+    return;
+  }
+  logger.warn(`An existing directory "${candidateDir}" was left untouched. ` + `The project was created inside the auto-created solution at "${projectDir}". ` + "Run init from inside an existing solution, or pass --skip-solution-registration, if you meant to use the existing directory.");
+}
+function resolveSolutionDir(fs, inputPath) {
+  const resolved = fs.path.resolve(inputPath);
+  if (resolved.endsWith(".uipx")) {
+    return fs.path.dirname(resolved);
+  }
+  return resolved;
+}
+async function updateUipxSolutionId(fs, uipxPath, newSolutionId) {
+  const [readError, content] = await catchError(fs.readFile(uipxPath, "utf-8"));
+  if (readError || !content) {
+    logger.error(`Could not read .uipx file for update: ${readError?.message ?? "empty file"}`);
+    return;
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  if (parseError) {
+    logger.error(`Could not parse .uipx file for update: ${parseError.message}`);
+    return;
+  }
+  parsed.SolutionId = newSolutionId;
+  const [writeError] = await catchError(fs.writeFile(uipxPath, JSON.stringify(parsed, null, 4)));
+  if (writeError) {
+    logger.error(`Could not update .uipx with new SolutionId: ${writeError.message}`);
+  } else {
+    logger.info(`Updated .uipx with Studio Web SolutionId: ${newSolutionId}`);
+  }
+}
+async function findSolutionFile(fs, projectPath) {
+  const parentDir = fs.path.resolve(projectPath, "..");
+  const [dirError, entries] = await catchError(fs.readdir(parentDir));
+  if (dirError) {
+    logger.error(`Could not read parent directory for .uipx file: ${dirError.message}`);
+    return;
+  }
+  const uipxFile = entries.find((entry) => entry.endsWith(".uipx"));
+  if (!uipxFile) {
+    logger.info("No .uipx solution file found in parent directory.");
+    return;
+  }
+  const uipxPath = fs.path.join(parentDir, uipxFile);
+  const [readError, content] = await catchError(fs.readFile(uipxPath, "utf-8"));
+  if (readError || content === null) {
+    logger.error(`Could not read .uipx file: ${readError?.message ?? "file returned null"}`);
+    return;
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  if (parseError) {
+    logger.error(`Could not parse .uipx file: ${parseError.message}`);
+    return;
+  }
+  const solutionId = parsed.SolutionId;
+  const projectId = parsed.Projects?.[0]?.Id;
+  if (!solutionId) {
+    logger.info("No SolutionId found in .uipx file.");
+    return;
+  }
+  logger.info(`Found solution file: ${uipxFile} (SolutionId: ${solutionId})`);
+  return {
+    solutionId,
+    projectId: projectId ?? crypto.randomUUID()
+  };
+}
+async function updateSolutionFile(fs, projectPath, newSolutionId) {
+  const parentDir = fs.path.resolve(projectPath, "..");
+  const [dirError, entries] = await catchError(fs.readdir(parentDir));
+  if (dirError)
+    return;
+  const uipxFile = entries.find((entry) => entry.endsWith(".uipx"));
+  if (!uipxFile)
+    return;
+  const uipxPath = fs.path.join(parentDir, uipxFile);
+  await updateUipxSolutionId(fs, uipxPath, newSolutionId);
+}
+async function tryRegisterProjectInParentSolution(fs, projectDir, options) {
+  if (options?.skipRegistration) {
+    return {
+      Status: "OptedOut",
+      Message: "Solution auto-registration skipped (--skip-solution-registration).",
+      Instructions: buildOptedOutInstructions(fs.path.resolve(projectDir))
+    };
+  }
+  const [registrationError, registration] = await catchError(registerProjectInParentSolution(fs, projectDir));
+  if (registrationError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Instructions: buildRegistrationFailureInstructions(projectDir, registrationError.message)
+    };
+  }
+  return registration;
+}
+async function registerProjectInParentSolution(fs, projectDir) {
+  const resolvedProjectDir = fs.path.resolve(projectDir);
+  const discovery = await findNearestParentUipxFile(fs, resolvedProjectDir);
+  if (discovery.status === "notFound") {
+    return {
+      Status: "NotInSolution",
+      Message: "Project created in standalone mode; no parent .uipx solution found.",
+      Instructions: buildStandaloneInstructions(resolvedProjectDir)
+    };
+  }
+  if (discovery.status === "skipped") {
+    return discovery.registration;
+  }
+  const solutionFile = discovery.solutionFile;
+  const solutionDir = fs.path.dirname(solutionFile);
+  const relativeProjectDir = fs.path.relative(solutionDir, resolvedProjectDir);
+  if (relativeProjectDir === "" || relativeProjectDir.startsWith("..") || fs.path.isAbsolute(relativeProjectDir)) {
+    return {
+      Status: "Skipped",
+      Message: "Project registration skipped.",
+      Solution: solutionFile,
+      Instructions: `Project must reside within the solution folder.
+  Solution: ${solutionDir}
+  Project:  ${resolvedProjectDir}`
+    };
+  }
+  const [projectFileError, projectFile] = await findProjectFile(fs, resolvedProjectDir);
+  if (projectFileError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Solution: solutionFile,
+      Instructions: buildRegistrationFailureInstructions(resolvedProjectDir, projectFileError.message)
+    };
+  }
+  const [projectManifestError, projectManifest] = await readProjectManifest(fs, projectFile.filePath, projectFile.useProjectJson);
+  if (projectManifestError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Solution: solutionFile,
+      Instructions: buildRegistrationFailureInstructions(resolvedProjectDir, projectManifestError.message)
+    };
+  }
+  const unsupportedReason = unsupportedSolutionProjectType(projectManifest.projectType);
+  if (unsupportedReason) {
+    return {
+      Status: "Skipped",
+      Message: "Project registration skipped.",
+      Solution: solutionFile,
+      Instructions: unsupportedReason
+    };
+  }
+  const projectRelativePath = toPortableRelativePath(fs.path.join(relativeProjectDir, projectFile.fileName));
+  const [solutionError, solution] = await readSolutionManifest(fs, solutionFile);
+  if (solutionError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Solution: solutionFile,
+      Project: projectRelativePath,
+      Instructions: buildRegistrationFailureInstructions(resolvedProjectDir, solutionError.message)
+    };
+  }
+  const existingProject = solution.projects.find((project) => toPortableRelativePath(project.ProjectRelativePath) === projectRelativePath);
+  if (existingProject) {
+    return {
+      Status: "AlreadyRegistered",
+      Message: "Project already registered in solution.",
+      Solution: solutionFile,
+      Project: projectRelativePath,
+      ProjectId: typeof existingProject.Id === "string" ? existingProject.Id : undefined,
+      Instructions: buildRegistrationSuccessInstructions(solutionDir)
+    };
+  }
+  const projectId = crypto.randomUUID();
+  solution.projects.push({
+    Type: normalizeProjectType(projectManifest.projectType),
+    ProjectRelativePath: projectRelativePath,
+    Id: projectId
+  });
+  solution.content.Projects = solution.projects;
+  const [writeError] = await catchError(fs.writeFile(solutionFile, `${JSON.stringify(solution.content, null, 2)}
+`));
+  if (writeError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Solution: solutionFile,
+      Project: projectRelativePath,
+      Instructions: buildRegistrationFailureInstructions(resolvedProjectDir, writeError.message)
+    };
+  }
+  return {
+    Status: "Registered",
+    Message: "Project registered in parent solution.",
+    Solution: solutionFile,
+    Project: projectRelativePath,
+    ProjectId: projectId,
+    Instructions: buildRegistrationSuccessInstructions(solutionDir)
+  };
+}
+async function findNearestParentUipxFile(fs, projectDir) {
+  let currentDir = fs.path.dirname(fs.path.resolve(projectDir));
+  while (true) {
+    const [readDirError, entries] = await catchError(fs.readdir(currentDir));
+    if (readDirError) {
+      return {
+        status: "skipped",
+        registration: {
+          Status: "Failed",
+          Message: "Project registration failed.",
+          Instructions: buildRegistrationFailureInstructions(projectDir, `Could not inspect parent directory for a solution: ${currentDir}
+${readDirError.message}`)
+        }
+      };
+    }
+    const solutionFiles = entries.filter((entry) => entry.endsWith(".uipx"));
+    if (solutionFiles.length > 1) {
+      return {
+        status: "skipped",
+        registration: {
+          Status: "Skipped",
+          Message: "Project registration skipped.",
+          Instructions: `Found multiple .uipx files in ${currentDir}: ${solutionFiles.join(", ")}. Run 'uip solution projects add "${projectDir}" <solution.uipx>' to choose one.`
+        }
+      };
+    }
+    if (solutionFiles.length === 1) {
+      return {
+        status: "found",
+        solutionFile: fs.path.join(currentDir, solutionFiles[0])
+      };
+    }
+    const parentDir = fs.path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return { status: "notFound" };
+    }
+    currentDir = parentDir;
+  }
+}
+async function findProjectFile(fs, projectDir) {
+  const uiprojPath = fs.path.join(projectDir, "project.uiproj");
+  if (await fs.exists(uiprojPath)) {
+    return [
+      null,
+      {
+        filePath: uiprojPath,
+        fileName: "project.uiproj",
+        useProjectJson: false
+      }
+    ];
+  }
+  const jsonProjectPath = fs.path.join(projectDir, "project.json");
+  if (await fs.exists(jsonProjectPath)) {
+    return [
+      null,
+      {
+        filePath: jsonProjectPath,
+        fileName: "project.json",
+        useProjectJson: true
+      }
+    ];
+  }
+  return [
+    new Error(`No project file found in ${projectDir}. Expected project.uiproj or project.json.`),
+    null
+  ];
+}
+async function readProjectManifest(fs, filePath, useProjectJson) {
+  const [readError, rawContent] = await catchError(fs.readFile(filePath, "utf-8"));
+  if (readError || !rawContent) {
+    return [readError ?? new Error(`Unable to read ${filePath}.`), null];
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(rawContent));
+  if (parseError) {
+    return [
+      new Error(`Invalid JSON in project file: ${parseError.message}`),
+      null
+    ];
+  }
+  if (!isRecord(parsed)) {
+    return [new Error(`Invalid project file: ${filePath}`), null];
+  }
+  const designOptions = parsed.designOptions;
+  const outputType = useProjectJson && isRecord(designOptions) ? readString(designOptions.outputType) : undefined;
+  const projectType = outputType ?? readString(parsed.ProjectType);
+  if (!projectType) {
+    return [new Error(`ProjectType not found in ${filePath}`), null];
+  }
+  return [
+    null,
+    {
+      projectType
+    }
+  ];
+}
+async function readSolutionManifest(fs, solutionFile) {
+  const [readError, rawContent] = await catchError(fs.readFile(solutionFile, "utf-8"));
+  if (readError || !rawContent) {
+    return [
+      readError ?? new Error(`Unable to read solution file: ${solutionFile}`),
+      null
+    ];
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(rawContent));
+  if (parseError) {
+    return [
+      new Error(`Invalid JSON in solution file: ${parseError.message}`),
+      null
+    ];
+  }
+  if (!isRecord(parsed)) {
+    return [
+      new Error(`Invalid solution file: ${solutionFile} must contain a JSON object.`),
+      null
+    ];
+  }
+  if (!Array.isArray(parsed.Projects)) {
+    return [
+      new Error(`Invalid solution file: ${solutionFile} must contain a Projects array.`),
+      null
+    ];
+  }
+  const projects = [];
+  for (const [index, project] of parsed.Projects.entries()) {
+    if (!isRecord(project)) {
+      return [
+        new Error(`Invalid solution file: Projects[${index}] must be an object.`),
+        null
+      ];
+    }
+    const projectRelativePath = readString(project.ProjectRelativePath);
+    if (!projectRelativePath) {
+      return [
+        new Error(`Invalid solution file: Projects[${index}] is missing ProjectRelativePath. Use 'uip solution projects add' to repair the manifest.`),
+        null
+      ];
+    }
+    projects.push({
+      ...project,
+      Type: readString(project.Type) ?? "",
+      ProjectRelativePath: projectRelativePath,
+      Id: readString(project.Id) ?? ""
+    });
+  }
+  return [null, { content: parsed, projects }];
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function buildRegistrationSuccessInstructions(solutionDir) {
+  return [
+    "The project is listed in the parent solution manifest.",
+    "Packing or uploading the solution will sync solution resources automatically.",
+    `To sync resources before packaging, run 'uip solution resources refresh --solution-folder "${solutionDir}"'.`
+  ].join(`
+`);
+}
+function buildRegistrationFailureInstructions(projectDir, details) {
+  return [
+    "Automatic solution registration could not complete.",
+    `Run 'uip solution projects add "${projectDir}" <solution.uipx>' after checking the project and solution files.`,
+    `Details: ${details}`
+  ].join(`
+`);
+}
+function buildStandaloneInstructions(projectDir) {
+  return [
+    "No parent solution was found by walking ancestor directories.",
+    "Studio Web upload, `flow debug`, and packaging require an enclosing solution.",
+    `To link this project to a solution, run 'uip solution init "<SolutionName>"' then 'uip solution projects add "${projectDir}" <SolutionName>.uipx'.`
+  ].join(`
+`);
+}
+function buildOptedOutInstructions(projectDir) {
+  return [
+    "Automatic solution registration was skipped because --skip-solution-registration was passed.",
+    `To register this project later, run 'uip solution projects add "${projectDir}" <SolutionName>.uipx' from within the solution.`
+  ].join(`
+`);
+}
+async function isProjectRegisteredInSolution(fs, projectDir, solutionFile) {
+  const [readErr, manifest] = await readSolutionManifest(fs, solutionFile);
+  if (readErr) {
+    throw readErr;
+  }
+  if (!manifest) {
+    throw new Error(`Unable to read solution manifest: ${solutionFile}`);
+  }
+  const solutionDir = fs.path.dirname(solutionFile);
+  const projectDirReal = await canonicalizePath(fs, projectDir);
+  for (const project of manifest.projects) {
+    const candidateDir = fs.path.resolve(solutionDir, fs.path.dirname(toPortableRelativePath(project.ProjectRelativePath)));
+    const candidateReal = await canonicalizePath(fs, candidateDir);
+    if (candidateReal === projectDirReal) {
+      return true;
+    }
+  }
+  return false;
+}
+async function canonicalizePath(fs, p) {
+  const [err, real] = await catchError(fs.realpath(p));
+  return err || !real ? p : real;
+}
+async function findSolutionFileUpward(fs, startDir) {
+  let dir = startDir;
+  while (true) {
+    const entries = await fs.readdir(dir);
+    const files = entries.filter((f) => f.endsWith(".uipx"));
+    if (files.length === 1) {
+      return fs.path.join(dir, files[0]);
+    }
+    if (files.length > 1) {
+      throw new Error(`Multiple .uipx files found in ${dir}. Please specify which solution file to use.`);
+    }
+    const parent = fs.path.dirname(dir);
+    if (parent === dir) {
+      throw new Error(`No .uipx solution file found (searched from ${startDir} to filesystem root)`);
+    }
+    dir = parent;
+  }
+}
+
+export { normalizeProjectType, toPortableRelativePath, readUipxFile, createSolutionManifest, autoScaffoldSolution, prepareProjectLocation, resolveSolutionDir, updateUipxSolutionId, findSolutionFile, updateSolutionFile, tryRegisterProjectInParentSolution, findNearestParentUipxFile, readSolutionManifest, isProjectRegisteredInSolution, findSolutionFileUpward };
+
+//# debugId=C68E91587DBDE36C64756E2164756E21