@uipath/solution-tool 1.204.0-preview.255 → 1.205.0-preview.256

package/dist/packager-tool-frr2xmkr.js

@@ -0,0 +1,445 @@
+import {
+  isCurrentRecordAsync
+} from "./packager-tool-5n6jsn41.js";
+import {
+  VALIDATION_CONFIRMATION_REQUIRED_CODE,
+  coerceWorkflowErrorMessages
+} from "./packager-tool-act5r386.js";
+import {
+  deploymentToTerminalPipelineResult,
+  findDeploymentBestEffort,
+  isPipelineDeploymentNotFoundError,
+  mapOperationStatusToPipelineStatus
+} from "./packager-tool-d6rrfd46.js";
+import {
+  resolvePersonalWorkspace
+} from "./packager-tool-rvt68c1t.js";
+import {
+  Configuration,
+  PipelinesApi
+} from "./packager-tool-97rcgwvv.js";
+import {
+  Configuration as Configuration2,
+  DeploymentsApi
+} from "./packager-tool-9t26kde1.js";
+import {
+  resolveFolder
+} from "./packager-tool-8ptbmmmp.js";
+import {
+  PollOutcome,
+  logger,
+  pollUntil,
+  processContext
+} from "./packager-tool-tx834spe.js";
+import {
+  catchError,
+  extractErrorDetails
+} from "./packager-tool-6ybywxxn.js";
+
+// src/services/activation.ts
+var TERMINAL_STATUSES = new Set([
+  "SuccessfulActivate",
+  "FailedActivate"
+]);
+async function activateDeployment(auth, deploymentName, options) {
+  const api = new PipelinesApi(new Configuration({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  const [stepsError, steps] = await catchError(api.pipelinesGetPreActivateSteps({ deploymentName }, options.scope));
+  if (stepsError) {
+    const { message, details, errorCode, retry, context } = await extractErrorDetails(stepsError);
+    const deployment = await findDeploymentBestEffort(auth, deploymentName, options.scope);
+    return {
+      kind: "RequestFailed",
+      phase: "preActivateSteps",
+      message,
+      details,
+      errorCode,
+      retry,
+      httpStatus: context?.httpStatus,
+      deployment
+    };
+  }
+  if (steps.steps.length > 0) {
+    logger.info(`Pre-activate steps for ${deploymentName}:`);
+    for (const step of steps.steps) {
+      logger.info(`  [${step.serviceName}] ${step.step}: ${step.description}`);
+    }
+  }
+  const [activateError, activateResult] = await catchError(api.pipelinesActivate({ deploymentName }, options.scope));
+  if (activateError) {
+    const { message, details, errorCode, retry, context } = await extractErrorDetails(activateError);
+    const deployment = await findDeploymentBestEffort(auth, deploymentName, options.scope);
+    return {
+      kind: "RequestFailed",
+      phase: "activate",
+      message,
+      details,
+      errorCode,
+      retry,
+      httpStatus: context?.httpStatus,
+      deployment
+    };
+  }
+  const instanceId = activateResult.instanceId;
+  if (!instanceId) {
+    return { kind: "NoInstance" };
+  }
+  const pollResult = await pollUntil({
+    fn: () => api.pipelinesGetDeploymentInstanceStatus({ instanceId }, options.scope),
+    until: (result) => TERMINAL_STATUSES.has(result.status),
+    getStatus: (result) => result.status,
+    label: `activate ${deploymentName}`,
+    logPrefix: "activate",
+    timeoutMs: options.timeoutSeconds * 1000,
+    intervalMs: options.pollIntervalMs,
+    signal: options.signal ?? processContext.pollSignal
+  });
+  if (pollResult.outcome !== PollOutcome.Completed || !pollResult.data) {
+    return { kind: "PollFailed", poll: pollResult };
+  }
+  const finalStatus = pollResult.data;
+  if (finalStatus.status !== "SuccessfulActivate") {
+    const errorMessage = coerceWorkflowErrorMessages(finalStatus.errorMessage).map((e) => e.errorMessage).join(", ") || "Unknown error";
+    return {
+      kind: "ActivationFailed",
+      status: finalStatus.status,
+      instanceId,
+      errorMessage
+    };
+  }
+  return {
+    kind: "Success",
+    status: finalStatus.status,
+    instanceId
+  };
+}
+
+// src/services/folder-helper.ts
+async function resolveParentFolder(options) {
+  if (!options.folderPath && !options.folderKey && !options.personalWorkspace) {
+    return;
+  }
+  if (options.personalWorkspace) {
+    const [pwError, pw] = await catchError(resolvePersonalWorkspace({
+      tenant: options.tenant,
+      loginValidity: options.loginValidity,
+      envFilePath: options.envFilePath
+    }));
+    if (pwError) {
+      throw new Error(`Failed to resolve Personal Workspace: ${pwError.message}`);
+    }
+    return pw.name;
+  }
+  if (options.folderPath) {
+    return options.folderPath;
+  }
+  const [resolveError, resolved] = await catchError(resolveFolder({ folderKey: options.folderKey }, {
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath
+  }));
+  if (resolveError) {
+    throw new Error(`Failed to resolve folder key '${options.folderKey}': ${resolveError.message}`);
+  }
+  if (!resolved) {
+    throw new Error(`Folder not found for key '${options.folderKey}'.`);
+  }
+  return resolved.path;
+}
+async function resolveFolderInfo(options) {
+  if (!options.folderPath && !options.folderKey) {
+    return;
+  }
+  const [resolveError, resolved] = await catchError(resolveFolder({ folderPath: options.folderPath, folderKey: options.folderKey }, {
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath
+  }));
+  if (resolveError) {
+    throw new Error(`Failed to resolve folder '${options.folderPath ?? options.folderKey}': ${resolveError.message}`);
+  }
+  if (!resolved) {
+    throw new Error(`Folder not found: '${options.folderPath ?? options.folderKey}'.`);
+  }
+  return { key: resolved.key, path: resolved.path };
+}
+
+// src/services/deployment-validation.ts
+var NO_SERVER_REASON = "the server reported no reason.";
+var LOOKUP_TIMEOUT_MS = 15000;
+function boundedScope(scope, signal) {
+  const deadline = AbortSignal.timeout(LOOKUP_TIMEOUT_MS);
+  const abort = signal ? AbortSignal.any([signal, deadline]) : deadline;
+  return async (requestContext) => ({
+    ...await scope?.(requestContext),
+    signal: abort
+  });
+}
+async function describeValidationFailureAsync(deploymentsApi, deploymentKey, deploymentAction, scope, signal) {
+  const [error, validation] = await catchError(deploymentsApi.deploymentsGetValidationResult({ deploymentKey, deploymentAction }, boundedScope(scope, signal)));
+  if (error || !validation) {
+    return NO_SERVER_REASON;
+  }
+  const messages = [
+    ...validation.validationErrors.map((item) => item.text || item.resource),
+    ...validation.resourceValidationErrors.flatMap((resource) => resource.errors.map((item) => item.text || item.resource))
+  ].filter(Boolean);
+  return messages.length > 0 ? messages.join("; ") : NO_SERVER_REASON;
+}
+async function describeDeploymentFailureAsync(auth, deployment, deploymentAction, scope, signal) {
+  const deploymentsApi = new DeploymentsApi(new Configuration2({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  const keys = [deployment.key, deployment.installDeploymentKey].filter((key, index, all) => Boolean(key) && all.indexOf(key) === index);
+  for (const key of keys) {
+    const reason = await describeValidationFailureAsync(deploymentsApi, key, deploymentAction, scope, signal);
+    if (reason !== NO_SERVER_REASON) {
+      return reason;
+    }
+  }
+  return NO_SERVER_REASON;
+}
+
+// src/services/permanent-deletion-consent.ts
+function isPermanentDeletionRefusal(status) {
+  return status?.status === "DeploymentScheduleError" && (status.deploymentScheduleErrors ?? []).some((error) => error.errorCode === VALIDATION_CONFIRMATION_REQUIRED_CODE);
+}
+function selectPermanentDeletionResources(validationErrors) {
+  const byKey = new Map;
+  for (const error of validationErrors) {
+    if (error.errorKind !== "RequiresConfirmation" || error.level !== "Warning" || !error.key || byKey.has(error.key)) {
+      continue;
+    }
+    byKey.set(error.key, {
+      key: error.key,
+      name: error.name || error.key,
+      ...error.kind ? { kind: error.kind } : {}
+    });
+  }
+  return [...byKey.values()];
+}
+async function listPermanentDeletionResourcesAsync(api, deploymentName, deploymentKey, scope, signal) {
+  if (!deploymentKey) {
+    logger.debug(`No deployment key to tie the validation result of '${deploymentName}' to`);
+    return;
+  }
+  const [error, validation] = await catchError(() => api.pipelinesGetDeploymentValidationResult({ deploymentName }, boundedScope(scope, signal)));
+  if (error || !validation) {
+    if (error) {
+      logger.debug(`Could not read the validation result of '${deploymentName}': ${error.message}`);
+    }
+    return;
+  }
+  if (!await isCurrentRecordAsync(api, deploymentKey, boundedScope(undefined, signal))) {
+    logger.debug(`The validation result of '${deploymentName}' is not provably record ${deploymentKey}'s: it was superseded, or the by-key lookup failed`);
+    return;
+  }
+  return selectPermanentDeletionResources(validation.validationErrors ?? []);
+}
+
+class AcknowledgePermanentDeletionError extends Error {
+  resource;
+  detail;
+  constructor(resource, detail) {
+    const reason = detail.details ? `${detail.message}: ${detail.details}` : detail.message;
+    super(`Acknowledging the permanent deletion of ${formatPermanentDeletionResource(resource)} (${resource.key}) failed: ${reason}`);
+    this.resource = resource;
+    this.detail = detail;
+    this.name = "AcknowledgePermanentDeletionError";
+  }
+}
+async function acknowledgePermanentDeletionAsync(api, deploymentName, resources, scope, signal) {
+  for (const resource of resources) {
+    const [error] = await catchError(() => api.pipelinesAcknowledgeResourcePermanentDeletion({
+      deploymentName,
+      resourceKey: resource.key,
+      acknowledged: true
+    }, boundedScope(scope, signal)));
+    if (error) {
+      throw new AcknowledgePermanentDeletionError(resource, await extractErrorDetails(error));
+    }
+    logger.info(`Acknowledged permanent deletion of ${formatPermanentDeletionResource(resource)}`);
+  }
+}
+function formatPermanentDeletionResource(resource) {
+  return resource.kind ? `${resource.kind} '${resource.name}'` : `'${resource.name}'`;
+}
+function formatPermanentDeletionResources(resources) {
+  return resources.map(formatPermanentDeletionResource).join(", ");
+}
+var ACKNOWLEDGE_PERMANENT_DELETION_FLAG = "--acknowledge-permanent-deletion";
+async function settlePermanentDeletionRefusalAsync(request) {
+  const deploymentKey = request.status.deploymentKey || undefined;
+  const resources = await listPermanentDeletionResourcesAsync(request.api, request.deploymentName, deploymentKey, request.scope, request.signal);
+  const draft = request.status.deploymentKey ? ` (${request.status.deploymentKey})` : "";
+  const nothingInstalled = `Nothing was installed; the attempt is kept as a pending draft${draft}.`;
+  if (!resources || resources.length === 0) {
+    const serverText = (request.status.deploymentScheduleErrors ?? []).filter((error) => error.errorCode === VALIDATION_CONFIRMATION_REQUIRED_CODE).map((error) => error.errorText).join(" ");
+    const why = resources ? "the deployment's validation result names no resource to confirm" : "the deployment's validation result could not be read, or the deployment changed under this run";
+    return {
+      ok: false,
+      reason: "permanent_deletion_confirmation_required",
+      message: `The server requires confirmation before ${request.verb.toLowerCase()} '${request.deploymentName}': ${serverText || "installed resources replaced by links would be permanently deleted with their data."}`,
+      instructions: request.acknowledge ? `The resources to confirm could not be listed (${why}), so none were acknowledged: the CLI only confirms deletions it can name. ${nothingInstalled} Retry the same command, or review the deployment in Orchestrator.` : `The resources could not be listed (${why}). ${nothingInstalled} To confirm, ${request.confirmHint}. To keep the installed copies instead, ${request.keepCopiesHint}.`,
+      classification: request.acknowledge ? {} : { errorCode: "invalid_argument", retry: "RetryWillNotFix" }
+    };
+  }
+  if (!request.acknowledge) {
+    return {
+      ok: false,
+      reason: "permanent_deletion_confirmation_required",
+      message: `${request.verb} '${request.deploymentName}' will permanently delete ${resources.length} installed resource(s) replaced by links: ${formatPermanentDeletionResources(resources)}, along with their data.`,
+      instructions: `${nothingInstalled} To confirm the deletion, ${request.confirmHint}. To keep the installed copies instead, ${request.keepCopiesHint}.`,
+      resources,
+      classification: {
+        errorCode: "invalid_argument",
+        retry: "RetryWillNotFix"
+      }
+    };
+  }
+  const [ackError] = await catchError(acknowledgePermanentDeletionAsync(request.api, request.deploymentName, resources, request.scope, request.signal));
+  if (ackError) {
+    return {
+      ok: false,
+      reason: "acknowledge_failed",
+      message: ackError.message,
+      instructions: `${nothingInstalled} The install was not re-run. Resources acknowledged before the failure stay acknowledged on the draft. Retry the same command once the server accepts the acknowledgement; a 404 means this server does not offer the Pipelines acknowledge route yet, so confirm the deletion in Orchestrator instead.`,
+      resources,
+      classification: ackError instanceof AcknowledgePermanentDeletionError ? {
+        errorCode: ackError.detail.errorCode,
+        retry: ackError.detail.retry
+      } : {}
+    };
+  }
+  const stillCurrent = deploymentKey !== undefined && await isCurrentRecordAsync(request.api, deploymentKey, boundedScope(undefined, request.signal));
+  if (!stillCurrent) {
+    return {
+      ok: false,
+      reason: "acknowledge_failed",
+      message: `Deployment '${request.deploymentName}' changed under this run: record ${deploymentKey} is no longer its current record, so the install was not re-run.`,
+      instructions: `Nothing was installed by this run. The acknowledgement was sent to the deployment by name, so another install or upgrade of '${request.deploymentName}' that landed meanwhile may now carry it: review the deployment in Orchestrator before running anything else.`,
+      resources,
+      classification: {
+        errorCode: "invalid_argument",
+        retry: "RetryWillNotFix"
+      }
+    };
+  }
+  return { ok: true, resources };
+}
+function acknowledgedButNotRunHint(resources, keepCopiesHint) {
+  return `The permanent deletion of ${formatPermanentDeletionResources(resources)} is already acknowledged on the kept draft, though nothing was deleted because the install did not run: re-running the same command deletes them without asking again. To keep the installed copies instead, ${keepCopiesHint}.`;
+}
+function stillRequiresConfirmation(deploymentName, resources, deploymentKey) {
+  const acknowledged = resources.map((resource) => resource.key).join(", ");
+  const draft = deploymentKey ? ` (${deploymentKey})` : "";
+  return {
+    reason: "permanent_deletion_confirmation_required",
+    message: `The server still requires confirmation for '${deploymentName}' after acknowledging ${acknowledged}.`,
+    instructions: `The install was re-run once and refused again, so the CLI stopped rather than loop. Nothing was installed; the attempt is kept as a pending draft${draft}. Review the deployment's resources in Orchestrator: another resource may need confirmation, or the acknowledgement did not reach the draft.`,
+    resources: [...resources],
+    classification: {}
+  };
+}
+
+// src/services/pipeline-deploy-poll.ts
+var PIPELINE_TERMINAL_STATUSES = new Set([
+  "DeploymentSucceeded",
+  "DeploymentFailed",
+  "ValidationFailed",
+  "ConflictFixingError",
+  "DeploymentScheduleError"
+]);
+function remainingTimeoutMs(timeoutMs, deadline) {
+  if (timeoutMs === 0) {
+    return 0;
+  }
+  return Math.max(1, deadline - Date.now());
+}
+var NO_ERRORS = {
+  validationResult: { validationErrors: [], conflictErrors: [] },
+  conflictFixingErrors: [],
+  deploymentScheduleErrors: []
+};
+function stillInFlight(deploymentKey) {
+  return {
+    status: "DeploymentInProgress",
+    deploymentKey: deploymentKey ?? "",
+    configurationKey: "",
+    ...NO_ERRORS
+  };
+}
+async function readOutcomeByKeyAsync(api, deploymentKey) {
+  const [error, info] = await catchError(() => api.pipelinesGetDeploymentByKey({ key: deploymentKey }));
+  if (error || !info) {
+    return;
+  }
+  if (info.deploymentKey !== deploymentKey) {
+    return;
+  }
+  if (info.operation === "Uninstall" || info.operationStatus === "Draft") {
+    return stillInFlight(deploymentKey);
+  }
+  const status = mapOperationStatusToPipelineStatus(info.operationStatus);
+  if (!status) {
+    return stillInFlight(deploymentKey);
+  }
+  return {
+    status,
+    deploymentKey: info.deploymentKey,
+    configurationKey: "",
+    ...NO_ERRORS,
+    synthesizedOperation: info.operation
+  };
+}
+async function pollPipelineDeploymentAsync(api, auth, options) {
+  let observedDeploymentKey;
+  return pollUntil({
+    fn: async () => {
+      try {
+        const status = await api.pipelinesGetPipelineDeploymentStatus({ pipelineDeploymentId: options.pipelineDeploymentId }, options.scope);
+        if (status.deploymentKey) {
+          observedDeploymentKey = status.deploymentKey;
+        }
+        return status;
+      } catch (err) {
+        if (!await isPipelineDeploymentNotFoundError(err)) {
+          throw err;
+        }
+        if (!observedDeploymentKey) {
+          return stillInFlight(undefined);
+        }
+        const byKey = await readOutcomeByKeyAsync(api, observedDeploymentKey);
+        if (byKey) {
+          return byKey;
+        }
+        const deployment = await findDeploymentBestEffort(auth, options.deploymentName, options.scope, { deploymentKey: observedDeploymentKey });
+        if (!deployment || deployment.operationStatus === "Draft") {
+          return stillInFlight(observedDeploymentKey);
+        }
+        const synthesized = deploymentToTerminalPipelineResult(deployment);
+        if (!synthesized) {
+          return stillInFlight(observedDeploymentKey);
+        }
+        return {
+          ...synthesized,
+          synthesizedOperation: deployment.operation
+        };
+      }
+    },
+    until: (result) => PIPELINE_TERMINAL_STATUSES.has(result.status),
+    getStatus: (result) => result.status,
+    label: `deployment ${options.pipelineDeploymentId}`,
+    logPrefix: options.logPrefix,
+    timeoutMs: options.timeoutMs,
+    intervalMs: options.intervalMs,
+    signal: options.signal
+  });
+}
+
+export { activateDeployment, resolveParentFolder, resolveFolderInfo, NO_SERVER_REASON, describeValidationFailureAsync, describeDeploymentFailureAsync, isPermanentDeletionRefusal, listPermanentDeletionResourcesAsync, formatPermanentDeletionResources, ACKNOWLEDGE_PERMANENT_DELETION_FLAG, settlePermanentDeletionRefusalAsync, acknowledgedButNotRunHint, stillRequiresConfirmation, remainingTimeoutMs, pollPipelineDeploymentAsync };
+
+//# debugId=0A59B0D65B5A781064756E2164756E21

package/dist/{packager-tool-v8bkkqdb.js → packager-tool-gmwva4yv.js}

@@ -1,9 +1,9 @@
-import {
-  catchError
-} from "./packager-tool-kswwd3hp.js";
 import {
   getAuthContext
-} from "./packager-tool-gb35b4qs.js";
+} from "./packager-tool-43ahv5mn.js";
+import {
+  catchError
+} from "./packager-tool-6ybywxxn.js";
 
 // src/services/studio-web-auth-middleware.ts
 var studioWebAuthByCommand = new WeakMap;
@@ -66,4 +66,4 @@ async function resolveStudioWebAuthContext(options) {
 
 export { useStudioWebAuth, getStudioWebAuth, getStudioWebAuthWithOrganizationId };
 
-//# debugId=407AA4762D049D2964756E2164756E21
+//# debugId=FCF746C59C6BE72F64756E2164756E21

package/dist/packager-tool-gs3f3tf7.js

@@ -0,0 +1,103 @@
+import {
+  catchError
+} from "./packager-tool-6ybywxxn.js";
+
+// src/services/pack-project-selection.ts
+function validatePackProjectOptions(options) {
+  if (options.project !== undefined && options.project.trim() === "") {
+    return "--project was given an empty value.";
+  }
+  if (options.project !== undefined && options.name !== undefined) {
+    return "--name cannot be used together with --project: it names the solution package, and --project packs a project package. Use --package-id to name that.";
+  }
+  if (options.packageId === undefined) {
+    return;
+  }
+  if (options.project === undefined) {
+    return "--package-id can only be used together with --project.";
+  }
+  if (options.packageId.trim() === "") {
+    return "--package-id was given an empty value.";
+  }
+  return;
+}
+
+class PackProjectError extends Error {
+  instructions;
+  errorCode = "invalid_argument";
+  constructor(message, instructions) {
+    super(message);
+    this.instructions = instructions;
+    this.name = "PackProjectError";
+  }
+}
+async function resolvePackProjectAsync(fs, solutionDir, selector) {
+  const { projects, solutionName } = await readPackProjectEntriesAsync(fs, solutionDir);
+  const wanted = normalizeRelativePath(selector);
+  const byId = projects.filter((p) => p.id.toLowerCase() === selector.trim().toLowerCase());
+  const matches = byId.length > 0 ? byId : projects.filter((p) => {
+    const file = normalizeRelativePath(p.relativePath);
+    return wanted !== "" && (file === wanted || projectFolder(file) === wanted);
+  });
+  if (matches.length === 1) {
+    assertInsideSolution(fs, solutionDir, selector, matches[0]);
+    return { project: matches[0], solutionName };
+  }
+  throw new PackProjectError(matches.length === 0 ? `Project '${selector}' is not part of the solution.` : `Project '${selector}' matches more than one project of the solution.`, choicesInstructions(matches.length === 0 ? projects : matches));
+}
+function assertInsideSolution(fs, solutionDir, selector, project) {
+  const instructions = "Fix the project's ProjectRelativePath in the .uipx so it names a project file inside the solution folder, then rerun.";
+  if (project.relativePath.trim() === "") {
+    throw new PackProjectError(`Project '${selector}' has no ProjectRelativePath in the .uipx.`, instructions);
+  }
+  const relative = fs.path.relative(solutionDir, fs.path.resolve(solutionDir, projectFolder(project.relativePath)));
+  if (relative === ".." || relative.startsWith("../") || relative.startsWith("..\\") || fs.path.isAbsolute(relative)) {
+    throw new PackProjectError(`Project '${selector}' points outside the solution folder: '${project.relativePath}'.`, instructions);
+  }
+  if (relative === "") {
+    throw new PackProjectError(`Project '${selector}' sits at the solution root ('${project.relativePath}'), so packing it on its own would pack the whole solution with it.`, "Move the project into its own folder inside the solution, update its ProjectRelativePath in the .uipx to match, then rerun.");
+  }
+}
+function choicesInstructions(projects) {
+  if (projects.length === 0) {
+    return "The solution lists no projects. Add one with 'uip solution project add', then rerun.";
+  }
+  const choices = projects.map((p) => `'${projectFolder(p.relativePath) || p.relativePath}' (Id: ${p.id})`).join(", ");
+  return `Pass --project with one of the solution's project Ids or paths: ${choices}.`;
+}
+async function readPackProjectEntriesAsync(fs, solutionDir) {
+  const entries = await fs.readdir(solutionDir);
+  const uipxFile = entries.find((entry) => entry.endsWith(".uipx"));
+  if (!uipxFile) {
+    throw new PackProjectError(`No .uipx solution file found in ${solutionDir}.`, "Pass the solution folder, the one that contains the .uipx file.");
+  }
+  const content = await fs.readFile(fs.path.join(solutionDir, uipxFile), "utf-8");
+  const [parseError, manifest] = catchError(() => JSON.parse(content ?? ""));
+  if (parseError) {
+    throw new PackProjectError(`Failed to parse ${uipxFile}: ${parseError.message}`, `Fix the JSON in ${uipxFile}, then rerun.`);
+  }
+  const projects = [];
+  for (const raw of Array.isArray(manifest?.Projects) ? manifest.Projects : []) {
+    const entry = raw;
+    if (typeof entry?.Id !== "string" || !entry.Id)
+      continue;
+    projects.push({
+      id: entry.Id,
+      type: typeof entry.Type === "string" ? entry.Type : "",
+      relativePath: typeof entry.ProjectRelativePath === "string" ? entry.ProjectRelativePath : ""
+    });
+  }
+  return { projects, solutionName: uipxFile.slice(0, -".uipx".length) };
+}
+function normalizeRelativePath(path) {
+  return path.trim().replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^(\.\/)+/, "").replace(/\/$/, "").toLowerCase();
+}
+function projectFolder(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  const slash = normalized.lastIndexOf("/");
+  return slash === -1 ? "" : normalized.slice(0, slash);
+}
+
+export { validatePackProjectOptions, PackProjectError, resolvePackProjectAsync, projectFolder };
+
+//# debugId=A02E54BA1CA9A95764756E2164756E21