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

package/dist/packager-tool-jg692f13.js

@@ -0,0 +1,517 @@
+import {
+  prepareSolutionResources
+} from "./packager-tool-t8gh825q.js";
+import {
+  resolveGovernanceFileTypeAsync,
+  validateGovernanceOptions
+} from "./packager-tool-47wzvqw0.js";
+import {
+  SOLUTION_PATH_INSTRUCTIONS,
+  applyAuthConnection,
+  checkSolutionPathAsync,
+  createSolutionPackager,
+  readSolutionFileAsUint8Array,
+  resolveSdkLogLevel
+} from "./packager-tool-jmpb786m.js";
+import {
+  ensurePackagerTools,
+  isUnpackableProjectTypeError
+} from "./packager-tool-b2nhscfk.js";
+import {
+  INVALID_PACKAGE_ID,
+  SolutionPackOptions
+} from "./packager-tool-wz34ma3s.js";
+import {
+  PackProjectError,
+  validatePackProjectOptions
+} from "./packager-tool-gs3f3tf7.js";
+import {
+  ToolResult
+} from "./packager-tool-pbmqk39a.js";
+import {
+  OutputFormatter,
+  RESULTS,
+  carriedErrorCode,
+  carriedRetry,
+  logger
+} from "./packager-tool-tx834spe.js";
+import {
+  carriedInstructions,
+  catchError
+} from "./packager-tool-6ybywxxn.js";
+import {
+  getFileSystem
+} from "./packager-tool-v1f5e8t9.js";
+import {
+  __require
+} from "./packager-tool-1de529jm.js";
+
+// src/services/pack-command-service.ts
+class PackCommandService {
+  packager = null;
+  fs;
+  constructor() {
+    this.fs = getFileSystem();
+  }
+  reportPackThrow(error, dryRun) {
+    const msg = error instanceof Error ? error.message : String(error);
+    const errorCode = carriedErrorCode(error) ?? (isUnpackableProjectTypeError(error) ? "invalid_argument" : undefined);
+    const contributionCode = error?.contributionCode;
+    const retry = carriedRetry(error);
+    const dryRunHint = "Inspect the reported error, fix the underlying issue in the solution, then rerun: uip solution pack <solution-path> --dry-run";
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      ...errorCode ? { ErrorCode: errorCode } : {},
+      ...retry ? { Retry: retry } : {},
+      ...typeof contributionCode === "string" ? { Context: { errorCode: contributionCode } } : {},
+      Message: msg,
+      Instructions: carriedInstructions(error) ?? (dryRun ? dryRunHint : msg)
+    });
+    if (errorCode || !(error instanceof Error) || !error.stack) {
+      return;
+    }
+    logger.error("Stack trace:");
+    logger.error(error.stack);
+  }
+  async execute(solutionPath, options, context) {
+    const check = await checkSolutionPathAsync(this.fs, solutionPath);
+    if (!check.ok) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: check.message,
+        Instructions: options.dryRun || check.kind === "wrong-type" ? SOLUTION_PATH_INSTRUCTIONS : check.message,
+        ErrorCode: check.errorCode
+      });
+      if (check.statError?.stack) {
+        logger.error("Stack trace:");
+        logger.error(check.statError.stack);
+      }
+      context.exit(1);
+      return;
+    }
+    const { absoluteSolutionPath, isUisFile, stats } = check;
+    const packageName = this.resolvePackageName(absoluteSolutionPath, isUisFile, options);
+    let resolvedOutput;
+    let tempDir;
+    if (options.dryRun) {
+      const [tempDirError, allocated] = await catchError(this.fs.getTempDir());
+      if (tempDirError || !allocated) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: tempDirError?.message ?? "Failed to allocate a temporary directory for dry-run validation.",
+          Instructions: "Ensure the OS temp directory is writable and try again."
+        });
+        context.exit(1);
+        return;
+      }
+      tempDir = allocated;
+      resolvedOutput = allocated;
+    } else if (options.output === undefined) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Missing required argument: outputPath.",
+        Instructions: "Provide an output directory, or pass --dry-run to validate without packing."
+      });
+      context.exit(1);
+      return;
+    } else {
+      resolvedOutput = this.fs.path.resolve(options.output);
+      if (stats.isDirectory()) {
+        const projectDir = await this.findMemberProjectCollision(absoluteSolutionPath, resolvedOutput);
+        if (projectDir) {
+          OutputFormatter.error({
+            Result: RESULTS.Failure,
+            Message: `Output path ${resolvedOutput} is inside member project "${this.fs.path.basename(projectDir)}" (${projectDir}). Anything written there gets packed into that project's package on the next pack.`,
+            Instructions: "Choose an output path outside the solution's project directories, e.g. ./out at the solution root or a directory outside the solution."
+          });
+          context.exit(1);
+          return;
+        }
+      }
+    }
+    if (options.dryRun) {
+      logger.info(`
+Validating solution (dry-run)...
+`);
+      logger.info("Details:");
+      logger.info(`  Solution: ${absoluteSolutionPath}`);
+      logger.info("");
+    } else if (options.project === undefined) {
+      logger.info(`
+Packing solution...
+`);
+      logger.info("Details:");
+      logger.info(`  Solution: ${absoluteSolutionPath}`);
+      logger.info(`  Package:  ${packageName}@${options.version}`);
+      logger.info(`  Output:   ${resolvedOutput}`);
+      logger.info("");
+    } else {
+      logger.info(`
+Packing project...
+`);
+      logger.info("Details:");
+      logger.info(`  Solution: ${absoluteSolutionPath}`);
+      logger.info(`  Project:  ${options.project}`);
+      if (options.packageId !== undefined) {
+        logger.info(`  Package:  ${options.packageId}@${options.version}`);
+      }
+      logger.info(`  Output:   ${resolvedOutput}`);
+      logger.info("");
+    }
+    let governanceFileType = options.governanceFileType;
+    if (options.governanceFilePath !== undefined) {
+      const resolved = await resolveGovernanceFileTypeAsync(this.fs, options.governanceFilePath);
+      if (!resolved.ok) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: resolved.message,
+          Instructions: resolved.instructions
+        });
+        context.exit(1);
+        return;
+      }
+      governanceFileType = resolved.fileType;
+    }
+    try {
+      const [error, result] = await catchError(this.executeAsync(solutionPath, {
+        ...options,
+        output: resolvedOutput,
+        governanceFileType
+      }));
+      if (error) {
+        this.reportPackThrow(error, options.dryRun === true);
+        context.exit(1);
+        return;
+      }
+      if (result.errorCode !== "SUCCESS" /* Success */) {
+        OutputFormatter.error(packFailureEnvelope(result, options.dryRun === true));
+        context.exit(1);
+        return;
+      }
+      if (options.dryRun) {
+        OutputFormatter.success({
+          Result: RESULTS.Success,
+          Code: "SolutionPack",
+          Data: {
+            Package: `${packedPackageName(result, packageName)}@${options.version}`,
+            DryRun: true,
+            Status: "Valid"
+          }
+        });
+      } else {
+        OutputFormatter.success({
+          Result: RESULTS.Success,
+          Code: "SolutionPack",
+          Data: {
+            Package: `${packedPackageName(result, packageName)}@${options.version}`,
+            Packages: result.packages.join(",")
+          }
+        });
+      }
+    } finally {
+      if (tempDir) {
+        const [rmError] = await catchError(this.fs.rm(tempDir));
+        if (rmError) {
+          logger.debug(`Failed to clean up dry-run temp directory ${tempDir}: ${rmError.message}`);
+        }
+      }
+    }
+  }
+  async checkPackInputs(solutionPath, options) {
+    if (options.output === undefined) {
+      return {
+        failure: new ToolResult("INTERNAL_ERROR" /* InternalError */, "Output path is required when invoking executeAsync directly.", [])
+      };
+    }
+    const projectError = validatePackProjectOptions(options);
+    if (projectError) {
+      return {
+        failure: new ToolResult("INTERNAL_ERROR" /* InternalError */, projectError, [])
+      };
+    }
+    const governanceError = validateGovernanceOptions(options);
+    if (governanceError) {
+      return {
+        failure: new ToolResult("INTERNAL_ERROR" /* InternalError */, governanceError, [])
+      };
+    }
+    let resolvedOptions = options;
+    if (options.governanceFilePath !== undefined && options.governanceFileType === undefined) {
+      const resolved = await resolveGovernanceFileTypeAsync(this.fs, options.governanceFilePath);
+      if (!resolved.ok) {
+        return {
+          failure: new ToolResult("INTERNAL_ERROR" /* InternalError */, `${resolved.message} ${resolved.instructions}`, [])
+        };
+      }
+      resolvedOptions = {
+        ...options,
+        governanceFileType: resolved.fileType
+      };
+    }
+    const check = await checkSolutionPathAsync(this.fs, solutionPath);
+    if (!check.ok) {
+      return {
+        failure: new ToolResult("INTERNAL_ERROR" /* InternalError */, check.message, [])
+      };
+    }
+    return {
+      absoluteOutputPath: this.fs.path.resolve(options.output),
+      resolvedOptions,
+      check
+    };
+  }
+  async executeAsync(solutionPath, options) {
+    const inputs = await this.checkPackInputs(solutionPath, options);
+    if (inputs.failure) {
+      return inputs.failure;
+    }
+    const { absoluteOutputPath, resolvedOptions, check } = inputs;
+    const { absoluteSolutionPath, isUisFile, stats } = check;
+    const isDirectory = stats.isDirectory();
+    const packageName = this.resolvePackageName(absoluteSolutionPath, isUisFile, options);
+    logger.debug(`Processing: ${absoluteSolutionPath}`);
+    logger.debug(`Package: ${packageName}@${options.version}`);
+    logger.debug(`Output: ${absoluteOutputPath}`);
+    const [copyError, copy] = await catchError(this.copyDirectoryForDryRun(absoluteSolutionPath, isDirectory && options.dryRun === true));
+    if (copyError) {
+      return new ToolResult("INTERNAL_ERROR" /* InternalError */, `Failed to prepare a temporary copy for the dry run: ${copyError.message}`, []);
+    }
+    const solutionRoot = copy?.solutionRoot ?? absoluteSolutionPath;
+    try {
+      if (resolvedOptions.project !== undefined) {
+        return await this.packProjectAsync(isUisFile, solutionRoot, absoluteOutputPath, resolvedOptions.project, resolvedOptions);
+      }
+      if (isDirectory) {
+        const [prepareError] = await catchError(this.prepareSolutionDirectoryForPack(solutionRoot));
+        if (prepareError) {
+          return toPackFailure(prepareError);
+        }
+      }
+      const [error, result] = await catchError(async () => {
+        await this.fs.mkdir(absoluteOutputPath);
+        const packager = await this.ensurePackagerAsync();
+        let inputPath;
+        if (isUisFile) {
+          const uint8Array = await readSolutionFileAsUint8Array(this.fs, absoluteSolutionPath);
+          inputPath = await packager.setupAsync(uint8Array);
+          await this.prepareSolutionDirectoryForPack(inputPath);
+        } else {
+          inputPath = await packager.setupAsync(solutionRoot);
+        }
+        await ensurePackagerTools(inputPath, this.fs);
+        const packOptions = await this.createPackOptions(inputPath, absoluteOutputPath, absoluteSolutionPath, isUisFile, resolvedOptions);
+        return packager.packSolutionAsync(packOptions);
+      });
+      return error ? toPackFailure(error) : result;
+    } finally {
+      if (copy) {
+        await this.discardDryRunCopy(copy.tempDir);
+      }
+    }
+  }
+  async packProjectAsync(isUisFile, solutionDir, outputPath, selector, options) {
+    if (isUisFile) {
+      throw new PackProjectError("--project packs a project out of a solution folder, not out of a .uis file.", "Pass the solution folder instead: uip solution pack <solution-folder> <output-path> --project <id-or-path>.");
+    }
+    const [error, result] = await catchError(async () => {
+      const { prepareSolutionProjectAsync, packSolutionProjectAsync } = await import("./pack-project-xwd1rbaa.js");
+      const { project, packageId } = await prepareSolutionProjectAsync(this.fs, solutionDir, selector, options.packageId);
+      await this.fs.mkdir(outputPath);
+      const packOptions = await this.createProjectPackOptions(project, packageId, outputPath, options);
+      return packSolutionProjectAsync(this.fs, project, packOptions);
+    });
+    return error ? toPackFailure(error) : result;
+  }
+  async copyDirectoryForDryRun(solutionDir, needed) {
+    if (!needed) {
+      return;
+    }
+    const tempDir = await this.fs.getTempDir();
+    const solutionRoot = this.fs.path.join(tempDir, this.fs.path.basename(solutionDir));
+    const [copyError] = await catchError(this.fs.copyDirectory(solutionDir, solutionRoot));
+    if (copyError) {
+      await this.discardDryRunCopy(tempDir);
+      throw copyError;
+    }
+    logger.debug(`Dry run works on a copy of the solution: ${solutionRoot}`);
+    return { tempDir, solutionRoot };
+  }
+  async discardDryRunCopy(tempDir) {
+    const [rmError] = await catchError(this.fs.rm(tempDir));
+    if (rmError) {
+      logger.debug(`Failed to clean up dry-run solution copy ${tempDir}: ${rmError.message}`);
+    }
+  }
+  async findMemberProjectCollision(solutionDir, outputPath) {
+    const projectDirs = await this.readMemberProjectDirs(solutionDir);
+    return projectDirs.find((projectDir) => this.isPathEqualOrInside(outputPath, projectDir));
+  }
+  isPathEqualOrInside(target, parent) {
+    const relative = this.fs.path.relative(parent, target);
+    if (relative === "") {
+      return true;
+    }
+    if (this.fs.path.isAbsolute(relative)) {
+      return false;
+    }
+    return relative !== ".." && !relative.startsWith("../") && !relative.startsWith("..\\");
+  }
+  async readMemberProjectDirs(solutionDir) {
+    const [listError, entries] = await catchError(this.fs.readdir(solutionDir));
+    const uipxFile = entries?.find((entry) => entry.endsWith(".uipx"));
+    if (listError || !uipxFile) {
+      return [];
+    }
+    const [readError, content] = await catchError(this.fs.readFile(this.fs.path.join(solutionDir, uipxFile), "utf-8"));
+    if (readError || !content) {
+      return [];
+    }
+    const [parseError, manifest] = catchError(() => JSON.parse(content));
+    const projects = manifest?.Projects;
+    if (parseError || !Array.isArray(projects)) {
+      return [];
+    }
+    const dirs = [];
+    for (const project of projects) {
+      if (typeof project !== "object" || project === null) {
+        continue;
+      }
+      const relativePath = project.ProjectRelativePath;
+      if (typeof relativePath === "string" && relativePath.trim()) {
+        dirs.push(this.fs.path.resolve(solutionDir, this.fs.path.dirname(relativePath)));
+      }
+    }
+    return dirs;
+  }
+  async prepareSolutionDirectoryForPack(solutionDir) {
+    await prepareSolutionResources(solutionDir, this.fs, { gate: true });
+  }
+  async ensurePackagerAsync() {
+    if (!this.packager) {
+      this.packager = await createSolutionPackager();
+    }
+    return this.packager;
+  }
+  resolvePackageName(absoluteSolutionPath, isUisFile, options) {
+    return options.name || (isUisFile ? this.fs.path.basename(absoluteSolutionPath, ".uis") : this.fs.path.basename(absoluteSolutionPath));
+  }
+  async createPackOptions(inputPath, outputPath, absoluteSolutionPath, isUisFile, options) {
+    const packOptions = new SolutionPackOptions;
+    packOptions.inputPath = inputPath;
+    packOptions.destinationPath = outputPath;
+    packOptions.configuration = "Release" /* Release */;
+    const packageName = this.resolvePackageName(absoluteSolutionPath, isUisFile, options);
+    packOptions.package = { id: packageName, ...packageMetadata(options) };
+    packOptions.solutionType = options.solutionType;
+    await applySharedPackOptions(packOptions, options);
+    return packOptions;
+  }
+  async createProjectPackOptions(project, packageId, outputPath, options) {
+    const projectPackager = await import("./node-7jm7ksqa.js");
+    const packOptions = new projectPackager.ProjectPackOptions;
+    packOptions.inputPath = project.ProjectPath ?? "";
+    packOptions.destinationPath = outputPath;
+    packOptions.package = { id: packageId, ...packageMetadata(options) };
+    await applySharedPackOptions(packOptions, options);
+    return packOptions;
+  }
+}
+function packageMetadata(options) {
+  return {
+    version: options.version || "1.0.0",
+    author: options.author?.trim() || undefined,
+    description: options.description?.trim() || undefined,
+    releaseNotes: options.releaseNotes,
+    projectUrl: options.projectUrl,
+    repositoryType: options.repositoryType,
+    repositoryUrl: options.repositoryUrl,
+    repositoryBranch: options.repositoryBranch,
+    repositoryCommit: options.repositoryCommit
+  };
+}
+async function applySharedPackOptions(packOptions, options) {
+  if (options.signingCertificatePath) {
+    packOptions.signingInfo = {
+      certificatePath: options.signingCertificatePath,
+      certificatePassword: options.signingCertificatePassword,
+      timestampServer: options.signingTimestampServer
+    };
+  }
+  packOptions.logLevel = resolveSdkLogLevel();
+  packOptions.excludeConfiguredSources = options.excludeConfiguredSources ?? false;
+  packOptions.nuGetSourcesConfigPath = options.nugetSourcesConfigPath;
+  packOptions.feedFolder = options.feedFolder;
+  packOptions.validateOptions = {
+    skipAnalyze: options.skipAnalyze ?? false,
+    skipValidate: false,
+    ignoredRules: options.ignoredRules,
+    governanceFileType: options.governanceFileType ?? resolveGovernanceFileType(options),
+    governanceFilePath: options.governanceFilePath,
+    profileKey: resolveGovernanceProduct(options)
+  };
+  const session = await applyAuthConnection(packOptions, options.loginValidity);
+  packOptions.validateOptions.sessionIdentityType = session.identity?.type;
+}
+function toPackFailure(error) {
+  if (isUnpackableProjectTypeError(error) || carriedErrorCode(error) !== undefined) {
+    throw error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  const instructions = carriedInstructions(error);
+  return new ToolResult("INTERNAL_ERROR" /* InternalError */, instructions ? `${message} ${instructions}` : message, []);
+}
+function packedPackageName(result, solutionPackageName) {
+  const ids = result.details?.packageIds;
+  return Array.isArray(ids) && ids.length > 0 ? ids.join(",") : solutionPackageName;
+}
+var DEFAULT_AUTOMATION_OPS_PRODUCT = "StudioWeb";
+function resolveGovernanceFileType(options) {
+  if (options.governanceFilePath !== undefined) {
+    return "Studio" /* Studio */;
+  }
+  return resolveGovernanceProduct(options) !== undefined ? "AutomationOps" /* AutomationOps */ : "Default" /* Default */;
+}
+function packFailureEnvelope(result, dryRun) {
+  const message = result.message ?? "Pack failed";
+  if (result.errorCode === INVALID_PACKAGE_ID) {
+    const rerun = dryRun ? "uip solution pack <solution-path> --dry-run" : "uip solution pack <solution-path> <output-path>";
+    return {
+      Result: RESULTS.Failure,
+      Message: message,
+      Instructions: `A member's package id is composed as '<solution>.<project-type>.<member-folder>', capped at 100 characters, and has to be unique across the solution — spaces and dots both collapse to a single dot, and NuGet ids are case-insensitive. The '<solution>' part is the '.uipx' file's own name; '--name' renames the archive only and cannot shorten a member id. Rename the member folder named in the message, or the '.uipx', then rerun ${rerun}.`,
+      ErrorCode: "invalid_argument",
+      Retry: "RetryWillNotFix"
+    };
+  }
+  return {
+    Result: RESULTS.Failure,
+    Message: `Error code: ${result.errorCode} : ${message}`,
+    Instructions: result.instructions ?? formatPackFailureInstructions(result.message, dryRun),
+    ...packFailureData(result)
+  };
+}
+function packFailureData(result) {
+  const projects = result.details?.projects;
+  return Array.isArray(projects) && projects.length > 0 ? { Data: { Projects: projects } } : {};
+}
+function resolveGovernanceProduct(options) {
+  const named = options.governanceProduct ?? options.automationOpsProfile;
+  if (named !== undefined) {
+    return named;
+  }
+  return options.governanceFilePath !== undefined || (options.ignoredRules?.length ?? 0) > 0 ? DEFAULT_AUTOMATION_OPS_PRODUCT : undefined;
+}
+function formatPackFailureInstructions(message, dryRun) {
+  const packMessage = message ?? "Pack failed";
+  const noPackagerMatch = /Cannot pack project type '([^']+)'/.exec(packMessage);
+  if (noPackagerMatch) {
+    const projectType = noPackagerMatch[1];
+    const rerunCommand = dryRun ? "uip solution pack <solution-path> --dry-run" : "uip solution pack <solution-path> <output-path>";
+    return `Install the tool that packs project type '${projectType}': run 'uip tools search' to find it, then 'uip tools install <tool>'. If '${projectType}' is a new project type, run 'uip update' first. Then rerun ${rerunCommand}.`;
+  }
+  return dryRun ? `${packMessage}. Resolve the reported issue (resource bindings, variable references, mapping targets, or runtime dependencies) and rerun: uip solution pack <solution-path> --dry-run` : packMessage;
+}
+
+export { PackCommandService, packFailureEnvelope };
+
+//# debugId=878D6966283DBC2164756E2164756E21

package/dist/packager-tool-jmpb786m.js

@@ -0,0 +1,109 @@
+import {
+  createNodeSolutionPackager
+} from "./packager-tool-wz34ma3s.js";
+import {
+  getLoginStatusAsync
+} from "./packager-tool-43ahv5mn.js";
+import {
+  logger,
+  telemetry
+} from "./packager-tool-tx834spe.js";
+import {
+  catchError
+} from "./packager-tool-6ybywxxn.js";
+
+// src/services/solution-packager-helpers.ts
+async function createSolutionPackager() {
+  return createNodeSolutionPackager({
+    logHandler: logger.handleLog,
+    telemetryService: telemetry
+  });
+}
+async function readSolutionFileAsUint8Array(fs, filePath) {
+  const fileData = await fs.readFile(filePath);
+  if (fileData === null) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  return fileData instanceof Uint8Array ? fileData : new Uint8Array(fileData);
+}
+function resolveSdkLogLevel() {
+  const sdkLogLevelMap = {
+    [0 /* DEBUG */]: "Debug" /* Debug */,
+    [1 /* INFO */]: "Information" /* Info */,
+    [2 /* WARN */]: "Warning" /* Warn */,
+    [3 /* ERROR */]: "Error" /* Error */
+  };
+  return sdkLogLevelMap[logger.getLevel()] ?? "Error" /* Error */;
+}
+async function applyAuthConnection(options, loginValidity) {
+  const loginStatus = await getLoginStatusAsync({
+    ensureTokenValidityMinutes: loginValidity
+  });
+  if (loginStatus.loginStatus) {
+    options.connection = {
+      accessToken: loginStatus.accessToken,
+      cloudUrl: orchestratorBaseUrl(loginStatus),
+      organizationId: loginStatus.organizationId,
+      tenantId: loginStatus.tenantId
+    };
+  }
+  return loginStatus;
+}
+function orchestratorBaseUrl(loginStatus) {
+  const { baseUrl, organizationId, tenantName } = loginStatus;
+  if (!baseUrl) {
+    return baseUrl;
+  }
+  let base = baseUrl;
+  while (base.endsWith("/")) {
+    base = base.slice(0, -1);
+  }
+  const segments = [];
+  if (organizationId) {
+    segments.push(organizationId);
+    if (tenantName) {
+      segments.push(tenantName);
+    }
+  }
+  return segments.length ? `${base}/${segments.join("/")}` : base;
+}
+
+// src/services/solution-path.ts
+var SOLUTION_PATH_INSTRUCTIONS = "Ensure the solution path exists and points to a solution directory (containing .uipx) or a .uis file.";
+async function checkSolutionPathAsync(fs, solutionPath) {
+  const absoluteSolutionPath = fs.path.resolve(solutionPath);
+  const [statError, stats] = await catchError(fs.stat(absoluteSolutionPath));
+  if (statError) {
+    return {
+      ok: false,
+      absoluteSolutionPath,
+      kind: "unreadable",
+      message: statError.message,
+      statError
+    };
+  }
+  if (!stats) {
+    return {
+      ok: false,
+      absoluteSolutionPath,
+      kind: "missing",
+      message: `Solution path does not exist: ${absoluteSolutionPath}`,
+      errorCode: "not_found"
+    };
+  }
+  const isUisFile = stats.isFile() && absoluteSolutionPath.endsWith(".uis");
+  if (!stats.isDirectory() && !isUisFile) {
+    return {
+      ok: false,
+      absoluteSolutionPath,
+      kind: "wrong-type",
+      message: `Solution path must be a directory or a .uis file: ${absoluteSolutionPath}`,
+      errorCode: "invalid_argument"
+    };
+  }
+  return { ok: true, absoluteSolutionPath, isUisFile, stats };
+}
+
+export { createSolutionPackager, readSolutionFileAsUint8Array, resolveSdkLogLevel, applyAuthConnection, SOLUTION_PATH_INSTRUCTIONS, checkSolutionPathAsync };
+
+//# debugId=E4EA1C14BCE5DE7C64756E2164756E21