@uipath/vertical-solutions-tool 1.204.0 → 1.205.0-preview.258

package/dist/deploy-service-qaykt7er.js

@@ -0,0 +1,1779 @@
+import {
+  SolutionDeploymentsError,
+  isCompletedUninstall,
+  isInstalledDeployment,
+  listDeploymentsNamed,
+  newestDeployment,
+  solutionNameFromManifest
+} from "./tool-tjhwq0ez.js";
+import {
+  describePauseKind,
+  finalizeSucceededJob,
+  pauseErrorCode,
+  pauseInstructions,
+  rejectSeedWithoutWait,
+  stoppedWatching
+} from "./tool-342sz3hm.js";
+import {
+  configKeyProblem,
+  getManifest,
+  listAllFolders,
+  listPackageVersions,
+  listPackages,
+  listVerticals,
+  normalizeVersions
+} from "./tool-e4qgwf9h.js";
+import"./tool-s9qbxa2g.js";
+import {
+  credentialsFailure,
+  readServiceUrl,
+  rejectBlankOptions
+} from "./tool-p589v2r5.js";
+import {
+  watchDeployJob,
+  watchOptionsFrom,
+  withCapacityRetry
+} from "./tool-gvmshnq9.js";
+import {
+  writeProgress,
+  writeStepSummary,
+  writeSuccessSummary,
+  writeWarning
+} from "./tool-v15vxc4x.js";
+import {
+  createVssConfig
+} from "./tool-xd2ejt3h.js";
+import {
+  toDeployFailure
+} from "./tool-r2epw08s.js";
+import {
+  submitDeployJob
+} from "./tool-mn1wkbhw.js";
+import {
+  VssApiError,
+  scopeQuery,
+  vssRequestParsed
+} from "./tool-4z1dy1rn.js";
+import {
+  jsonObject,
+  optionalText
+} from "./tool-87e2ps7f.js";
+import"./tool-38ad77wd.js";
+import {
+  checkBeforeResubmitting,
+  routingFlags
+} from "./tool-cag2z2d6.js";
+import {
+  failure,
+  invalidOption,
+  missingOption
+} from "./tool-h4f967yd.js";
+import {
+  forDisplay,
+  forDisplayIfSet
+} from "./tool-rr9fensp.js";
+import {
+  DEPLOY_ACTIONS
+} from "./tool-s04z9t80.js";
+import {
+  exports_external
+} from "./tool-vf2mgth0.js";
+import {
+  RESULTS,
+  canPrompt,
+  catchError,
+  resolveEnvReference
+} from "./tool-pz9qm3dv.js";
+import {
+  getFileSystem
+} from "./tool-hdxtgckw.js";
+import"./tool-1yh8g550.js";
+
+// src/services/manifest-configurations.ts
+var SECRET_TERMS = [
+  "secret",
+  "password",
+  "passwd",
+  "pwd",
+  "token",
+  "credential",
+  "apikey",
+  "api-key",
+  "api_key",
+  "accesskey",
+  "access-key",
+  "access_key",
+  "privatekey",
+  "private-key",
+  "private_key",
+  "connectionstring",
+  "connection-string",
+  "connection_string",
+  "passphrase"
+];
+function looksSecret(key) {
+  return secretTermIn(key) !== undefined;
+}
+function secretTermIn(key) {
+  const lower = key.toLowerCase();
+  return SECRET_TERMS.find((term) => lower.includes(term));
+}
+function parseConfigPairs(pairs) {
+  const entries = [];
+  const literalSecretKeys = [];
+  for (const [index, pair] of pairs.entries()) {
+    const separator = pair.indexOf("=");
+    if (separator < 0) {
+      throw new Error(`Invalid --config value #${index + 1}: expected KEY=VALUE, but there is no '='.`);
+    }
+    const key = pair.slice(0, separator).trim();
+    const raw = pair.slice(separator + 1);
+    if (!key) {
+      throw new Error(`Invalid --config value #${index + 1}: the key before '=' is empty.`);
+    }
+    const problem = configKeyProblem(key);
+    if (problem) {
+      throw new Error(`Invalid --config value #${index + 1}: ${problem}`);
+    }
+    const isEnvReference = raw.startsWith("env.");
+    if (!isEnvReference && looksSecret(key)) {
+      literalSecretKeys.push(key);
+    }
+    entries.push({ key, value: raw });
+  }
+  return { entries, literalSecretKeys };
+}
+function normalizeConfigFileValues(parsed, path) {
+  const document = jsonObject.safeParse(parsed);
+  if (!document.success) {
+    throw new TypeError(`${path} must contain a JSON/YAML object of KEY: VALUE pairs.`);
+  }
+  const entries = [];
+  const literalSecretKeys = [];
+  for (const [key, raw] of Object.entries(document.data)) {
+    const problem = configKeyProblem(key);
+    if (problem)
+      throw new Error(`${path}: ${problem}`);
+    const value = exports_external.string().safeParse(raw);
+    if (!value.success) {
+      throw new TypeError(`${path}: the value of "${key}" must be a string.`);
+    }
+    if (!value.data.startsWith("env.") && looksSecret(key)) {
+      literalSecretKeys.push(key);
+    }
+    entries.push({ key, value: value.data });
+  }
+  return { entries, literalSecretKeys };
+}
+function mergeConfigurations(fileEntries, flagEntries) {
+  const merged = Object.create(null);
+  for (const entry of [...fileEntries, ...flagEntries]) {
+    merged[entry.key] = entry.value;
+  }
+  for (const key of Object.keys(merged)) {
+    const [error, value] = catchError(() => resolveEnvReference(merged[key]));
+    if (error || value === undefined) {
+      throw new Error(`Configuration ${key}: ${error?.message ?? "could not be read"}.`);
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+
+// src/services/collect-configurations.ts
+var NOTHING_DECLARED = new Map;
+async function collectConfigurations(manifest, options, prompts) {
+  const warnings = [];
+  const fromFile = await readConfigFile(options.configFile);
+  if (!fromFile.ok)
+    return fromFile;
+  const [parseError, parsed] = catchError(() => parseConfigPairs(options.config ?? []));
+  if (parseError || !parsed) {
+    return invalidOption(parseError?.message ?? "Could not read --config.", "Use --config KEY=VALUE, and --config KEY=env.MY_VAR for a secret.");
+  }
+  for (const key of parsed.literalSecretKeys) {
+    warnings.push(`'${key}' was given a literal value on the command line, where it lands in ` + `shell history, 'ps' output and CI logs. Prefer --config ${key}=env.MY_VAR.`);
+  }
+  for (const key of fromFile.literalSecretKeys) {
+    warnings.push(`'${key}' has a literal value in ${options.configFile ?? "the config file"}, which is ` + `usually committed. Prefer ${key}: env.MY_VAR and keep the secret in the environment.`);
+  }
+  const [mergeError, configurations] = catchError(() => mergeConfigurations(fromFile.entries, parsed.entries));
+  if (mergeError || !configurations) {
+    return invalidOption(mergeError?.message ?? "Could not read the configuration values.", "Set the environment variable, or pass the value with --config KEY=VALUE.");
+  }
+  const declared = manifest.configurations ?? NOTHING_DECLARED;
+  warnings.push(...undeclaredKeys(declared, configurations));
+  const missing = missingRequiredKeys(declared, configurations);
+  const badDeclaration = reservedDeclaration(missing);
+  if (badDeclaration)
+    return badDeclaration;
+  if (missing.length === 0) {
+    return { ok: true, configurations, warnings };
+  }
+  if (!canPrompt()) {
+    return missingOption(`Configuration for ${missing.join(", ")}`, `--config ${missing[0]}=<value> (or --config ${missing[0]}=env.MY_VAR for a secret)`);
+  }
+  for (const key of missing) {
+    const value = await promptRequired(key, declared.get(key), prompts);
+    if (value === undefined) {
+      return missingOption(`A value for ${key}`, `--config ${key}=<value> (or --config ${key}=env.MY_VAR for a secret)`);
+    }
+    configurations[key] = value;
+  }
+  return { ok: true, configurations, warnings };
+}
+var MAX_PROMPT_ATTEMPTS = 10;
+async function promptRequired(key, meta, prompts) {
+  for (let attempt = 0;attempt < MAX_PROMPT_ATTEMPTS; attempt += 1) {
+    const entered = await prompts.askValue(key, {
+      description: meta?.description,
+      defaultValue: meta?.value,
+      secret: meta?.isSecret || secretTermIn(key) !== undefined
+    });
+    const trimmed = entered?.trim();
+    if (trimmed)
+      return trimmed;
+    writeWarning(`A value for ${key} is required.`);
+  }
+  return;
+}
+async function readConfigFile(path) {
+  if (path === undefined) {
+    return { ok: true, entries: [], literalSecretKeys: [] };
+  }
+  const fs = getFileSystem();
+  if (!await fs.exists(path)) {
+    return failure("invalid-option", `--config-file not found: ${path}`, "Check the path, or drop the flag and pass values with --config KEY=VALUE.");
+  }
+  const [readError, contents] = await catchError(fs.readFile(path, "utf-8"));
+  if (readError || contents === null) {
+    return failure("invalid-option", `Failed to read ${path}: ${readError?.message ?? "the file is empty"}`, "Check the file is readable, or drop --config-file and pass values with " + "--config KEY=VALUE.");
+  }
+  const [parseError, parsed] = catchError(() => parseConfigDocument(contents));
+  if (parseError || parsed === undefined) {
+    return failure("invalid-option", `${path} is not valid JSON or YAML: ${parseError?.message ?? "unknown error"}`, "Fix the file so it parses as a JSON or YAML object of KEY: VALUE pairs.");
+  }
+  const [normalizeError, values] = catchError(() => normalizeConfigFileValues(parsed, path));
+  if (normalizeError || !values) {
+    return failure("invalid-option", normalizeError?.message ?? `Could not read ${path}.`, "Fix the file: a flat JSON or YAML object of KEY: VALUE pairs, string values only.");
+  }
+  return { ok: true, ...values };
+}
+function parseConfigDocument(contents) {
+  const trimmed = contents.trim();
+  if (trimmed === "")
+    throw new Error("the file is empty");
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return JSON.parse(trimmed);
+  }
+  const [jsonError, json] = catchError(() => JSON.parse(trimmed));
+  if (!jsonError)
+    return json;
+  return parseFlatYaml(trimmed);
+}
+function parseFlatYaml(trimmed) {
+  const result = Object.create(null);
+  for (const [index, rawLine] of trimmed.split(/\r?\n/).entries()) {
+    const line = rawLine.trim();
+    if (line === "" || line.startsWith("#"))
+      continue;
+    if (/^[ \t]/.test(rawLine)) {
+      throw new Error(`line ${index + 1}: nested values are not supported — write one flat "key: value" per line`);
+    }
+    const separator = line.indexOf(":");
+    if (separator <= 0) {
+      throw new Error(`line ${index + 1}: expected "key: value"`);
+    }
+    const key = line.slice(0, separator).trim();
+    const problem = configKeyProblem(key);
+    if (problem)
+      throw new Error(`line ${index + 1}: ${problem}`);
+    const raw = line.slice(separator + 1).trim();
+    if (raw === "") {
+      throw new Error(`line ${index + 1}: "${key}" has no value — write \`${key}: ""\` for an empty ` + 'one, or flatten a nested block into one "key: value" per line');
+    }
+    result[key] = raw.replace(/^["'](.*)["']$/, "$1");
+  }
+  return result;
+}
+var DEPLOY_SET_KEYS = new Set([
+  "UIPATH_BASE_URL",
+  "UIPATH_ORG_ID",
+  "UIPATH_ORG_NAME",
+  "UIPATH_TENANT_ID",
+  "UIPATH_TENANT_NAME",
+  "UIPATH_FOLDER_KEY",
+  "UIPATH_FOLDER_ID",
+  "UIPATH_FOLDER_PATH"
+]);
+function undeclaredKeys(declared, configurations) {
+  return Object.keys(configurations).flatMap((key) => {
+    if (DEPLOY_SET_KEYS.has(key)) {
+      return [
+        `${key} is set by the deploy itself, which takes precedence over this value.`
+      ];
+    }
+    return declared.size === 0 || declared.has(key) ? [] : [
+      `${key} is not a configuration this package declares, so nothing reads it.`
+    ];
+  });
+}
+function reservedDeclaration(missing) {
+  for (const key of missing) {
+    const problem = configKeyProblem(key);
+    if (problem) {
+      return invalidOption(`The package manifest declares a configuration it cannot take: ${problem}`, "Fix the configuration keys in the package manifest and publish it again.");
+    }
+  }
+  return;
+}
+function missingRequiredKeys(declared, collected) {
+  return [...declared].filter(([key, meta]) => meta.isRequired && (!Object.hasOwn(collected, key) || collected[key].trim() === "")).map(([key]) => key);
+}
+
+// src/services/deploy-config.ts
+var CAPS = {
+  maxResources: 20,
+  maxPropertiesPerResource: 20,
+  maxKeyLength: 100,
+  maxValueLength: 1024,
+  maxNameLength: 200
+};
+var ROUTING_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
+var ROUTING_NAME_RULE = "a routing name must be lowercase letters, digits and hyphens, at most 32 characters";
+var DeployConfigDocumentSchema = exports_external.looseObject({
+  version: exports_external.unknown().optional(),
+  externalApp: exports_external.unknown().optional(),
+  resources: exports_external.unknown().optional()
+});
+var DeployConfigResourceSchema = exports_external.looseObject({
+  name: exports_external.string().optional(),
+  kind: exports_external.string().optional(),
+  configuration: jsonObject.nullish()
+});
+async function discoverDeployConfig(explicitPath) {
+  const fs = getFileSystem();
+  if (explicitPath !== undefined) {
+    if (!await fs.exists(explicitPath)) {
+      throw new Error(`--resource-config file not found: ${explicitPath}`);
+    }
+    return explicitPath;
+  }
+  const candidate = fs.path.join(fs.env.cwd(), "deploy-config.json");
+  return await fs.exists(candidate) ? candidate : undefined;
+}
+function describeValue(value) {
+  if (typeof value === "object" && value !== null) {
+    return Array.isArray(value) ? "an array" : "an object";
+  }
+  const text = JSON.stringify(value) ?? String(value);
+  return text.length > 40 ? `${text.slice(0, 40)}…` : text;
+}
+async function loadDeployConfig(path) {
+  const fs = getFileSystem();
+  const [readError, contents] = await catchError(fs.readFile(path, "utf-8"));
+  if (readError || contents === null) {
+    throw new Error(`Failed to read ${path}: ${readError?.message ?? "the file is empty"}`);
+  }
+  const [parseError, json] = catchError(() => JSON.parse(contents));
+  const document = DeployConfigDocumentSchema.safeParse(json);
+  if (parseError || !document.success) {
+    throw new Error(`${path} is not valid JSON: ${parseError?.message ?? "it must be a JSON object"}`);
+  }
+  const { version, externalApp, resources } = document.data;
+  const warnings = [];
+  if (version !== undefined && version !== 1) {
+    throw new Error(`${path}: unsupported version ${describeValue(version)} — only 1 is supported.`);
+  }
+  if (externalApp !== undefined) {
+    warnings.push(`${path}: the 'externalApp' block is ignored — external-app auto-creation was removed. ` + "Register the application yourself and supply its id as 'externalClientId'.");
+  }
+  const entries = exports_external.array(exports_external.unknown()).safeParse(resources);
+  if (!entries.success) {
+    throw new TypeError(`${path}: 'resources' must be an array.`);
+  }
+  return {
+    path,
+    resources: entries.data.map((entry, index) => parseResource(entry, index, path)),
+    warnings
+  };
+}
+function parseResource(entry, index, path) {
+  const parsed = DeployConfigResourceSchema.safeParse(entry);
+  if (!parsed.success) {
+    throw resourceError(parsed.error.issues[0]?.path[0], index, path);
+  }
+  const configuration = {};
+  for (const [key, value] of Object.entries(parsed.data.configuration ?? {})) {
+    configuration[key] = parseConfigurationEntry(key, value, path);
+  }
+  return { ...parsed.data, configuration };
+}
+function resourceError(field, index, path) {
+  if (field === "name") {
+    return new Error(`${path}: 'name' must be a string when present.`);
+  }
+  if (field === "kind") {
+    return new Error(`${path}: 'kind' must be a string when present.`);
+  }
+  if (field === "configuration") {
+    return new Error(`${path}: 'configuration' must be an object.`);
+  }
+  return new TypeError(`${path}: 'resources[${index}]' must be an object with 'name', 'kind' and 'configuration'.`);
+}
+function parseConfigurationEntry(key, value, path) {
+  const reserved = configKeyProblem(key);
+  if (reserved) {
+    throw new Error(`${path}: ${reserved}`);
+  }
+  const forbidden = secretTermIn(key);
+  if (forbidden) {
+    throw new Error(`${path}: '${key}' looks like a secret (contains "${forbidden}"). ` + "This file is meant to be committed and its values are stored unencrypted — " + "pass secret values with --config KEY=env.VAR instead.");
+  }
+  const text = exports_external.string().safeParse(value);
+  if (!text.success) {
+    throw new TypeError(`${path}: the value of '${key}' must be a string.`);
+  }
+  if (key === "routingName" && !ROUTING_NAME_PATTERN.test(text.data)) {
+    throw new Error(`${path}: 'routingName' is not valid — ${ROUTING_NAME_RULE}.`);
+  }
+  return text.data;
+}
+
+// src/services/resource-payload.ts
+function buildPayload(resolved, displayNames, warnings) {
+  const payload = [];
+  for (const [key, values] of resolved) {
+    const name = displayNames.get(key) ?? key;
+    if (name.length > CAPS.maxNameLength) {
+      warnings.push(`Skipping resource '${name.slice(0, 40)}…': the name exceeds ${CAPS.maxNameLength} characters.`);
+      continue;
+    }
+    const configuration = buildResourceConfiguration(name, values, warnings);
+    if (Object.keys(configuration).length === 0)
+      continue;
+    if (payload.length >= CAPS.maxResources) {
+      warnings.push(`Dropping resource '${name}': at most ${CAPS.maxResources} resources may be configured.`);
+      continue;
+    }
+    payload.push({ name, configuration });
+  }
+  return payload;
+}
+function buildResourceConfiguration(name, values, warnings) {
+  const configuration = {};
+  for (const [property, value] of values) {
+    const dropReason = propertyDropReason(property, value, Object.keys(configuration).length);
+    if (dropReason !== undefined) {
+      warnings.push(`Dropping '${name}.${property}': ${dropReason}`);
+      continue;
+    }
+    configuration[property] = value;
+  }
+  return configuration;
+}
+function propertyDropReason(property, value, keptSoFar) {
+  if (property.length > CAPS.maxKeyLength) {
+    return `the property name exceeds ${CAPS.maxKeyLength} characters.`;
+  }
+  if (value.length > CAPS.maxValueLength) {
+    return `the value exceeds ${CAPS.maxValueLength} characters.`;
+  }
+  if (property === "routingName" && !ROUTING_NAME_PATTERN.test(value)) {
+    return `${ROUTING_NAME_RULE}. The deployment will pause for it instead.`;
+  }
+  if (keptSoFar >= CAPS.maxPropertiesPerResource) {
+    return `a resource may carry at most ${CAPS.maxPropertiesPerResource} properties.`;
+  }
+  return;
+}
+
+// src/services/declared-configuration.ts
+function validateRoutingNameAnswer(value) {
+  const trimmed = value.trim();
+  if (trimmed === "" || ROUTING_NAME_PATTERN.test(trimmed))
+    return true;
+  return `${ROUTING_NAME_RULE[0].toUpperCase()}${ROUTING_NAME_RULE.slice(1)}.`;
+}
+var NOTHING_DECLARED2 = { properties: [], warnings: [] };
+function parseDeclaredConfiguration(manifest) {
+  return manifest.solution?.configuration ?? NOTHING_DECLARED2;
+}
+async function collectDeclaredConfiguration(input) {
+  const declaration = parseDeclaredConfiguration(input.manifest);
+  const warnings = [...declaration.warnings, ...input.file?.warnings ?? []];
+  const { resolved, displayNames, fromFile } = seedFromFile(input, declaration, warnings);
+  const unresolvedRequired = [];
+  for (const property of declaration.properties) {
+    const key = property.resourceName.toLowerCase();
+    const values = resolved.get(key) ?? new Map;
+    if (!displayNames.has(key)) {
+      displayNames.set(key, property.resourceName);
+    }
+    await resolveDeclaredProperty(property, values, input, warnings, unresolvedRequired);
+    resolved.set(key, values);
+  }
+  if (input.isFreshInstall) {
+    warnUnresolvedRequired(unresolvedRequired, warnings);
+  }
+  const payload = buildPayload(resolved, displayNames, warnings);
+  return { payload, warnings, unresolvedRequired, fromFile };
+}
+function seedFromFile(input, declaration, warnings) {
+  const resolved = new Map;
+  const displayNames = new Map;
+  const fromFile = new Map;
+  const declared = new Set(declaration.properties.map((property) => property.resourceName.toLowerCase()));
+  for (const resource of input.file?.resources ?? []) {
+    const name = resolveFileResourceName(resource, input, declaration);
+    if (name === undefined) {
+      warnings.push("Skipping a deploy-config entry with no 'name': the manifest does not declare " + "exactly one configurable resource, so the name cannot be inferred.");
+      continue;
+    }
+    const key = name.toLowerCase();
+    if (declared.size > 0 && !declared.has(key)) {
+      warnings.push(`deploy-config names resource '${name}', which this solution's ` + "manifest does not declare as configurable — the entry is ignored.");
+      continue;
+    }
+    displayNames.set(key, name);
+    const values = resolved.get(key) ?? new Map;
+    const supplied = fromFile.get(key) ?? new Set;
+    for (const [property, value] of Object.entries(resource.configuration ?? {})) {
+      if (value.trim() === "")
+        continue;
+      values.set(property, value);
+      supplied.add(property);
+    }
+    resolved.set(key, values);
+    fromFile.set(key, supplied);
+  }
+  return { resolved, displayNames, fromFile };
+}
+async function resolveDeclaredProperty(property, values, input, warnings, unresolvedRequired) {
+  const secretTerm = secretTermIn(property.propertyName);
+  if (secretTerm) {
+    values.delete(property.propertyName);
+    warnings.push(`Skipping ${property.resourceName}.${property.propertyName}: its name contains ` + `'${secretTerm}', and per-resource values are stored unencrypted on the deploy ` + "job. Set it in the portal's configuration wizard instead.");
+    return;
+  }
+  if (values.has(property.propertyName))
+    return;
+  if (property.hasManifestValue)
+    return;
+  const typed = await askFor(property, input);
+  if (typed !== undefined && typed !== "") {
+    values.set(property.propertyName, typed);
+  } else if (property.required) {
+    unresolvedRequired.push(`${property.resourceName}.${property.propertyName}`);
+  }
+}
+function warnUnresolvedRequired(unresolvedRequired, warnings) {
+  for (const label of unresolvedRequired) {
+    warnings.push(`${label} is declared required by the package but no value was supplied — ` + "the deployment will pause and offer the portal's configuration wizard for it. " + "Set it in deploy-config.json to deploy without stopping.");
+  }
+}
+async function askFor(property, input) {
+  if (!input.isFreshInstall || !canPrompt())
+    return;
+  const typed = await input.prompts.askValue(`${property.resourceName}.${property.propertyName}`, {
+    description: property.description,
+    defaultValue: property.defaultValue,
+    secret: false,
+    ...property.propertyName === "routingName" ? { validate: validateRoutingNameAnswer } : {}
+  });
+  return typed?.trim();
+}
+function resolveFileResourceName(resource, input, declaration) {
+  if (resource.name)
+    return resource.name;
+  const declaredNames = new Set(declaration.properties.map((property) => property.resourceName));
+  if (input.file?.resources.length === 1 && declaredNames.size === 1) {
+    return [...declaredNames][0];
+  }
+  return;
+}
+
+// src/services/manifest-preflight.ts
+function hasEntries(section) {
+  return Object.keys(section ?? {}).length > 0;
+}
+function findTenantResources(manifest) {
+  const findings = [];
+  if (manifest.dataFabric?.schemaFilename) {
+    findings.push({
+      step: "DF_SCHEMA",
+      manifestKey: "dataFabric.schemaFilename",
+      describe: "a Data Fabric entity schema to import"
+    });
+  }
+  if (manifest.ixp) {
+    findings.push({
+      step: "IXP",
+      manifestKey: "ixp",
+      describe: "an IXP project, taxonomy and ML models"
+    });
+  }
+  if (hasEntries(manifest.storageBuckets)) {
+    findings.push({
+      step: "TOP_BUCKETS",
+      manifestKey: "storageBuckets",
+      describe: "tenant-level storage buckets"
+    });
+  }
+  if (hasEntries(manifest.indexes)) {
+    findings.push({
+      step: "TOP_INDEXES",
+      manifestKey: "indexes",
+      describe: "tenant-level context-grounding indexes"
+    });
+  }
+  if (manifest.webapp) {
+    findings.push({
+      step: "WEBAPP",
+      manifestKey: "webapp",
+      describe: "a web application to register and publish"
+    });
+  }
+  return findings;
+}
+function describeTenantResources(findings) {
+  return findings.map((f) => `  - ${f.manifestKey} (${f.describe}) — step ${f.step}`).join(`
+`);
+}
+
+// src/api/deployments.ts
+var DeploymentSchema = exports_external.looseObject({
+  id: exports_external.string(),
+  folderKey: exports_external.string(),
+  packageVersion: exports_external.string(),
+  status: optionalText,
+  deploymentName: optionalText
+});
+var DeploymentListSchema = exports_external.looseObject({
+  items: exports_external.array(DeploymentSchema).optional()
+});
+async function findCurrentDeployments(config, packageName, signal) {
+  const result = await vssRequestParsed(config, "deployments", DeploymentListSchema, {
+    query: {
+      ...scopeQuery(config),
+      packageName,
+      isCurrent: "true"
+    },
+    signal
+  });
+  return result.items ?? [];
+}
+
+// src/services/target/folder-index.ts
+var FOLDER_LIST_CONTEXT = "Could not list Orchestrator folders";
+async function loadFolderLabels(config, listFolders, signal) {
+  const [error, folders] = await catchError(listFolders(config, signal));
+  const aborted = abortedLookup(signal, error, FOLDER_LIST_CONTEXT);
+  if (aborted)
+    return aborted;
+  if (error || !folders)
+    return { ok: true, labels: new Map, read: true };
+  return {
+    ok: true,
+    labels: new Map(folders.map((folder) => [folder.key.toLowerCase(), folder.path])),
+    folders,
+    read: true
+  };
+}
+function pathFor(labels, folderKey) {
+  return labels.get(folderKey.toLowerCase());
+}
+function labelFor(labels, folderKey) {
+  return pathFor(labels, folderKey) ?? folderKey;
+}
+function sameKey(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+function keyForPath(labels, lowerCasePath) {
+  for (const [key, path] of labels) {
+    if (path.toLowerCase() === lowerCasePath)
+      return key;
+  }
+  return;
+}
+function abortedLookup(signal, error, context) {
+  if (!signal?.aborted)
+    return;
+  return toDeployFailure(signal.reason ?? error, context);
+}
+
+// src/services/target/folder-selector.ts
+function folderSelector(options, folderIndex) {
+  const path = options.folderPath?.trim();
+  if (options.folderPath !== undefined && !path) {
+    return invalidOption("--folder-path cannot be empty.", "Drop --folder-path, or pass a folder path.");
+  }
+  const folderKey = options.folderKey?.trim();
+  if (options.folderKey !== undefined && !folderKey) {
+    return invalidOption("--folder-key cannot be empty.", "Drop --folder-key, or pass the folder's key.");
+  }
+  if (folderKey) {
+    return keySelector(folderKey, path, options, folderIndex);
+  }
+  if (!path)
+    return;
+  if (!folderIndex.folders)
+    return uncheckablePath(path, options);
+  const matches = foldersForPath(path, folderIndex.labels);
+  if (matches.size === 0)
+    return unknownPath(path);
+  if (matches.size > 1) {
+    return invalidOption(`--folder-path ${path} matches ${matches.size} folders: ` + `${[...matches.values()].join(", ")}.`, "Pass the full path of the one you mean, or --folder-key <guid>.");
+  }
+  return {
+    ok: true,
+    flag: `--folder-path ${path}`,
+    option: "--folder-path",
+    keys: new Set(matches.keys())
+  };
+}
+function inFolder(deployment, folder) {
+  return folder.keys.has(deployment.folderKey.toLowerCase());
+}
+function unknownPath(path) {
+  return invalidOption(`--folder-path ${path} matches no Orchestrator folder in this tenant.`, "Pass the full path as Orchestrator shows it (for example Shared/Production), " + "or the folder's key with --folder-key <guid>.");
+}
+function keySelector(folderKey, path, options, folderIndex) {
+  const key = folderKey.toLowerCase();
+  const selector = {
+    ok: true,
+    flag: `--folder-key ${folderKey}`,
+    option: "--folder-key",
+    keys: new Set([key])
+  };
+  if (!path)
+    return selector;
+  if (!folderIndex.folders) {
+    return uncheckablePathWithKey(path, folderKey, options) ?? selector;
+  }
+  const pathKeys = foldersForPath(path, folderIndex.labels);
+  if (pathKeys.size === 0)
+    return unknownPath(path);
+  if (!pathKeys.has(key)) {
+    return invalidOption(`--folder-path ${path} and --folder-key ${folderKey} name different folders.`, "Drop one of the two, or correct it so both point at the same folder.");
+  }
+  return selector;
+}
+function uncheckablePathWithKey(path, folderKey, options) {
+  if (options.deploymentName) {
+    writeProgress(`  Could not read the Orchestrator folders to check --folder-path ${path} ` + `against --folder-key ${folderKey}; picking the deployment by --deployment-name.`);
+    return;
+  }
+  return failure("service-error", `Could not read the Orchestrator folders to check --folder-path ${path} ` + `against --folder-key ${folderKey}.`, "Drop --folder-path and pick the deployment by --folder-key alone, or by " + "--deployment-name <name>, or give this login the right to read Orchestrator folders.", { errorCode: "server_error", retry: "RetryLater" });
+}
+function uncheckablePath(path, options) {
+  if (options.deploymentName) {
+    writeProgress(`  Could not read the Orchestrator folders to check --folder-path ${path}; ` + "picking the deployment by --deployment-name.");
+    return;
+  }
+  return failure("service-error", `Could not read the Orchestrator folders to resolve --folder-path ${path}.`, "Pick the deployment with --folder-key <guid> or --deployment-name <name> instead, " + "or give this login the right to read Orchestrator folders.", { errorCode: "server_error", retry: "RetryLater" });
+}
+function foldersForPath(path, folderLabels) {
+  const wanted = path.toLowerCase();
+  const entries = [...folderLabels].map(([key, label]) => ({
+    key: key.toLowerCase(),
+    label,
+    lower: label.toLowerCase()
+  }));
+  const byPath = entries.filter((entry) => entry.lower === wanted);
+  const matches = byPath.length > 0 || wanted.includes("/") ? byPath : entries.filter((entry) => entry.lower.split("/").pop() === wanted);
+  return new Map(matches.map((entry) => [entry.key.toLowerCase(), entry.label]));
+}
+
+// src/services/target/action.ts
+async function resolveAction(existing, options, prompts, folderIndex) {
+  const folderLabels = folderIndex.labels;
+  const requested = options.action?.toLowerCase();
+  const requestedAction = DEPLOY_ACTIONS.find((action) => action === requested);
+  if (requested !== undefined && requestedAction === undefined) {
+    return invalidOption(`Unknown --action "${options.action}".`, `Use one of: ${DEPLOY_ACTIONS.join(", ")}.`);
+  }
+  if (requestedAction === "install") {
+    return { ok: true, action: "install", explicit: true };
+  }
+  if (requestedAction === "upgrade" || requestedAction === "downgrade") {
+    if (existing.length === 0) {
+      return invalidOption(`--action ${requestedAction} needs an existing deployment, but none is installed for this package.`, "Use --action install for a first deployment.");
+    }
+    const picked2 = await chooseExistingDeployment(existing, options, prompts, folderIndex);
+    if (!picked2.ok)
+      return picked2;
+    if (picked2.deployment === undefined) {
+      return ambiguousDeployment(existing, folderLabels);
+    }
+    return {
+      ok: true,
+      action: requestedAction,
+      deployment: picked2.deployment,
+      explicit: true
+    };
+  }
+  if (existing.length === 0) {
+    return { ok: true, action: "install", explicit: false };
+  }
+  if (!canPrompt()) {
+    return missingOption(`This package is already deployed (${describeDeployments(existing, folderLabels)}), so the intent`, "--action install|upgrade|downgrade");
+  }
+  const mode = await prompts.chooseDeployMode(existing.map((deployment) => ({
+    deployment,
+    folderLabel: labelFor(folderLabels, deployment.folderKey)
+  })));
+  if (mode === "fresh") {
+    return { ok: true, action: "install", explicit: false };
+  }
+  const picked = await chooseExistingDeployment(existing, options, prompts, folderIndex);
+  if (!picked.ok)
+    return picked;
+  if (picked.deployment === undefined) {
+    return ambiguousDeployment(existing, folderLabels);
+  }
+  return {
+    ok: true,
+    action: "upgrade",
+    deployment: picked.deployment,
+    explicit: false
+  };
+}
+function ambiguousDeployment(existing, folderLabels) {
+  const named = existing.some((deployment) => deployment.deploymentName);
+  return failure("ambiguous-deployment", `This package has ${existing.length} current deployments: ${describeDeployments(existing, folderLabels)}.`, named ? "Name the one to act on with --deployment-name <name>, or pin its folder with " + "--folder-key <guid>. Both are shown above." : "Name the one to act on with --folder-key <guid>. The key of each is shown above.", { result: RESULTS.ValidationError, errorCode: "invalid_argument" });
+}
+function describeDeployments(existing, folderLabels) {
+  return existing.map((deployment) => {
+    const label = pathFor(folderLabels, deployment.folderKey);
+    const where = label ? `${label} (${deployment.folderKey})` : deployment.folderKey;
+    const named = deployment.deploymentName ? `${deployment.deploymentName} ` : "";
+    return `${named}${deployment.packageVersion} in ${where}`;
+  }).join("; ");
+}
+function deploymentLabel(deployment, folderLabels) {
+  const folder = labelFor(folderLabels, deployment.folderKey);
+  return deployment.deploymentName ? `${deployment.deploymentName} — ${folder}` : folder;
+}
+function pickExistingDeployment(existing, options, folderIndex) {
+  const folderLabels = folderIndex.labels;
+  const folder = folderSelector(options, folderIndex);
+  if (folder && !folder.ok)
+    return folder;
+  const byName = pickByDeploymentName(existing, options, folderLabels, folder);
+  if (!byName.ok || byName.deployment)
+    return byName;
+  if (folder)
+    return pickByFolder(existing, folder, options, folderLabels);
+  return {
+    ok: true,
+    deployment: existing.length === 1 ? existing[0] : undefined
+  };
+}
+function pickByDeploymentName(existing, options, folderLabels, folder) {
+  const none = { ok: true, deployment: undefined };
+  const wanted = options.deploymentName?.trim().toLowerCase();
+  if (!wanted)
+    return none;
+  const named = existing.filter((deployment) => deployment.deploymentName?.trim().toLowerCase() === wanted);
+  if (named.length === 1) {
+    if (folder && !inFolder(named[0], folder)) {
+      return conflictingFlags(options, folder);
+    }
+    return { ok: true, deployment: named[0] };
+  }
+  if (named.length > 1) {
+    return invalidOption(`--deployment-name ${options.deploymentName} matches ${named.length} current ` + `deployments of this package: ${describeDeployments(named, folderLabels)}.`, "Pin the one to act on with --folder-key <guid>.");
+  }
+  if (!folder && existing.some((d) => d.deploymentName)) {
+    return invalidOption(`--deployment-name ${options.deploymentName} does not match any current ` + `deployment of this package. Deployed as: ${describeDeploymentNames(existing)}.`, "Pass one of the names listed, or select by folder with --folder-key.");
+  }
+  return none;
+}
+function conflictingFlags(options, folder) {
+  return invalidOption(`--deployment-name ${options.deploymentName} and ${folder.flag} ` + "name different deployments.", "Drop one of the two, or correct it so both point at the same deployment.");
+}
+function pickByFolder(existing, folder, options, folderLabels) {
+  const picked = existing.filter((deployment) => inFolder(deployment, folder));
+  if (picked.length === 1) {
+    return options.deploymentName && picked[0].deploymentName ? conflictingFlags(options, folder) : { ok: true, deployment: picked[0] };
+  }
+  if (picked.length > 1) {
+    return invalidOption(`${folder.flag} matches ${picked.length} current deployments ` + `of this package: ${describeDeploymentNames(picked)}.`, "Name the one to act on with --deployment-name <name>.");
+  }
+  return invalidOption(`${folder.flag} does not match any current deployment of this ` + `package. Deployed in: ${describeDeployments(existing, folderLabels)}.`, `Pass the folder of one of the deployments listed, or drop ${folder.option} ` + "and name the deployment with --deployment-name.");
+}
+function describeDeploymentNames(existing) {
+  const named = existing.map((deployment) => deployment.deploymentName).filter((name) => Boolean(name));
+  return named.length > 0 ? named.join(", ") : "none of them carries a name";
+}
+async function chooseExistingDeployment(existing, options, prompts, folderIndex) {
+  const byFlag = pickExistingDeployment(existing, options, folderIndex);
+  if (!byFlag.ok || byFlag.deployment || existing.length < 2 || !canPrompt()) {
+    return byFlag;
+  }
+  const picked = await prompts.pickOne("Deployment", existing.map((deployment) => ({
+    name: `${deploymentLabel(deployment, folderIndex.labels)} (v${deployment.packageVersion})`,
+    value: deployment.id
+  })));
+  return {
+    ok: true,
+    deployment: existing.find((deployment) => deployment.id === picked)
+  };
+}
+
+// src/services/target/deployment-name.ts
+async function resolveDeploymentName(defaultName, parentFolder, options, prompts) {
+  if (options.deploymentName)
+    return options.deploymentName;
+  if (!canPrompt())
+    return;
+  writeProgress(`
+Deployment name (optional)
+` + `  Creates a NEW folder "${parentFolder}/<name>" and names the deployment (unique per tenant).
+` + `  Leave blank to use "${defaultName}"; give one to install this package into more than ` + "one folder (e.g. UAT + Prod).");
+  const typed = await prompts.askText("Name");
+  return typed?.trim() || undefined;
+}
+function upgradeName(deployment, options) {
+  return options.deploymentName || deployment?.deploymentName || undefined;
+}
+
+// src/services/target/version.ts
+async function resolveVersion(config, packageName, stage, decision, options, prompts) {
+  const [error, nav] = await catchError(listPackageVersions(config, packageName, {
+    stage,
+    anchorVersion: decision.deployment?.packageVersion,
+    after: 100,
+    before: 1,
+    signal: options.signal
+  }));
+  if (error || !nav) {
+    return toDeployFailure(error, `Could not list versions of ${packageName}`);
+  }
+  const versions = normalizeVersions(nav);
+  if (options.packageVersion !== undefined) {
+    if (!options.packageVersion.trim()) {
+      return invalidOption("--package-version cannot be empty.", "Pass a package version or omit --package-version to select one.");
+    }
+    const validated = validateRequestedVersion(options.packageVersion, versions);
+    return typeof validated === "string" ? { ok: true, version: validated, versions, picked: false } : validated;
+  }
+  if (decision.action === "install") {
+    return resolveInstallVersion(packageName, versions, prompts);
+  }
+  if (decision.action === "downgrade") {
+    return resolveDowngradeVersion(packageName, stage, decision.deployment, versions, prompts);
+  }
+  return resolveUpgradeVersion(packageName, stage, decision.deployment, versions, prompts);
+}
+function settleProvisionalAction(action, explicit, versionPicked, version, versions) {
+  const settled = reconcileAction(action, version, versions);
+  if (!explicit || versionPicked)
+    return settled;
+  if (settled === action)
+    return action;
+  return invalidOption(`--action ${action} does not match --package-version ${version}, which is ` + `${settled === "upgrade" ? "newer" : "older"} than the installed version.`, `Pass --action ${settled} for that version, or name the version you meant to ` + `${action} with --package-version.`);
+}
+async function resolveInstallVersion(packageName, versions, prompts) {
+  if (versions.length === 0) {
+    return failure("unknown-version", `No versions of ${packageName} are published.`, "Check the package name, or ask the package's author whether it has been published.", { result: RESULTS.Failure });
+  }
+  if (versions.length === 1 || !canPrompt()) {
+    return {
+      ok: true,
+      version: versions[0].version,
+      versions,
+      picked: false
+    };
+  }
+  const picked = await prompts.pickOne("Version", versions.map((version) => ({
+    name: describeVersion(version),
+    value: version.version
+  })));
+  return { ok: true, version: picked, versions, picked: true };
+}
+async function resolveDowngradeVersion(packageName, stage, deployment, versions, prompts) {
+  if (!canPrompt()) {
+    return missingOption("A version to downgrade to", "--package-version <version>");
+  }
+  const older = versions.filter((version) => version.relation === "previous" && version.allowed !== false);
+  if (older.length === 0) {
+    return failure("unknown-version", `${packageName} has no older deployable version at stage "${stage}" ` + `(installed: ${deployment.packageVersion}).`, "Pass --package-version <version> to name an older version, or run " + "--action upgrade instead.", { result: RESULTS.Failure });
+  }
+  const picked = await prompts.pickOne("Version", older.map((version) => ({
+    name: describeVersion(version),
+    value: version.version
+  })));
+  return { ok: true, version: picked, versions, picked: true };
+}
+async function resolveUpgradeVersion(packageName, stage, deployment, versions, prompts) {
+  const candidates = versions.filter((version) => version.version !== deployment.packageVersion);
+  if (candidates.length === 0) {
+    return failure("unknown-version", `${packageName} has no other deployable version ` + `(installed: ${deployment.packageVersion}).`, "A newer version has to be published before it can be deployed.", { result: RESULTS.Failure });
+  }
+  if (!canPrompt()) {
+    const upgrade = candidates.find((version) => version.relation === "next" && !isBlockedVersion(version));
+    if (upgrade) {
+      return {
+        ok: true,
+        version: upgrade.version,
+        versions,
+        picked: false
+      };
+    }
+    return failure("unknown-version", `${packageName} is already at the newest deployable version ` + `(${deployment.packageVersion}). Other versions at stage "${stage}": ` + `${candidates.map((v) => describeVersion(v)).join(", ")}.`, "Name one explicitly with --package-version <version> — a downgrade is " + "never chosen automatically.");
+  }
+  const shown = upgradePickerRows(candidates);
+  const picked = await prompts.pickOne("Version", shown.map((version) => ({
+    name: describeVersion(version),
+    value: version.version
+  })));
+  const selected = shown.find((version) => version.version === picked);
+  if (!selected) {
+    return failure("unknown-version", `Unknown version ${picked}.`, "Run the command again and pick a version from the list, or pass " + "--package-version <version>.", { result: RESULTS.ValidationError, errorCode: "invalid_argument" });
+  }
+  if (!isBlockedVersion(selected)) {
+    return { ok: true, version: selected.version, versions, picked: true };
+  }
+  return offerSteppingStone(selected, deployment, versions, prompts);
+}
+function upgradePickerRows(candidates) {
+  const shown = candidates.filter((version) => version.relation !== "previous").slice(0, 3);
+  const stone = shown.find((version) => version.requiredVersion)?.requiredVersion;
+  if (stone && shown.every((version) => version.version !== stone)) {
+    const stoneEntry = candidates.find((version) => version.version === stone);
+    if (stoneEntry)
+      shown.push(stoneEntry);
+  }
+  const downgrade = candidates.find((version) => version.relation === "previous");
+  if (downgrade)
+    shown.push(downgrade);
+  return shown;
+}
+async function offerSteppingStone(selected, deployment, versions, prompts) {
+  if (!selected.requiredVersion) {
+    return failure("blocked-major-upgrade", `Version ${selected.version} is not deployable from the installed ` + `version ${deployment.packageVersion}.`, "Pick a different version.");
+  }
+  let stone;
+  let required = selected.requiredVersion;
+  const seen = new Set;
+  while (required !== undefined && !seen.has(required)) {
+    seen.add(required);
+    const candidate = versions.find((version) => version.version === required);
+    if (!candidate) {
+      return failure("blocked-major-upgrade", `Upgrading from ${deployment.packageVersion} to ${selected.version} ` + `needs ${required} first, which is not published.`, "That version has to be published before this upgrade can run.");
+    }
+    if (!isBlockedVersion(candidate)) {
+      stone = candidate;
+      break;
+    }
+    required = candidate.requiredVersion;
+  }
+  if (!stone) {
+    return failure("blocked-major-upgrade", `Upgrading from ${deployment.packageVersion} to ${selected.version} ` + "is blocked, and the versions it requires first are blocked too.", "Pick a version the sequential-major rule allows from the installed one.");
+  }
+  const accepted = await prompts.confirmSteppingStone({
+    installed: deployment.packageVersion,
+    wanted: selected.version,
+    stone: stone.version
+  });
+  if (!accepted) {
+    return failure("blocked-major-upgrade", "Deploy canceled: the chosen version cannot be reached in one step.", "Deploy the version the sequential-major rule requires first, then run this " + "command again for the one you wanted.");
+  }
+  return { ok: true, version: stone.version, versions, picked: true };
+}
+function describeVersion(version) {
+  if (version.allowed === false && version.requiredVersion) {
+    return `${version.version} (upgrade — blocked: requires ${version.requiredVersion} first)`;
+  }
+  if (version.relation === "current")
+    return `${version.version} (installed)`;
+  if (version.relation === "previous")
+    return `${version.version} (downgrade)`;
+  if (version.relation === "next")
+    return `${version.version} (upgrade)`;
+  return `${version.version} (available)`;
+}
+function isBlockedVersion(version) {
+  return version.allowed === false || version.relation === "blocked";
+}
+function validateRequestedVersion(requested, versions) {
+  const match = versions.find((version) => version.version === requested);
+  if (!match)
+    return requested;
+  if (isBlockedVersion(match)) {
+    return failure("blocked-major-upgrade", `Version ${requested} cannot be deployed from the installed version.`, match.requiredVersion ? `Majors are breaking changes and cannot be skipped. Deploy ${match.requiredVersion} first: ` + `--package-version ${match.requiredVersion}` : "Majors are breaking changes and cannot be skipped. Deploy the next published major first.");
+  }
+  return requested;
+}
+function reconcileAction(action, chosenVersion, versions) {
+  if (action === "install")
+    return action;
+  const match = versions.find((version) => version.version === chosenVersion);
+  if (match?.relation === "previous")
+    return "downgrade";
+  if (match?.relation === "next")
+    return "upgrade";
+  return action;
+}
+
+// src/services/target/name-collision.ts
+var NAME_ATTEMPTS = 10;
+async function settleNameCollision(input) {
+  const unchanged = {
+    ok: true,
+    action: input.action,
+    deploymentName: input.deploymentName,
+    target: input.target.target,
+    targetLabel: input.target.label
+  };
+  if (input.action !== "install")
+    return unchanged;
+  const lookUp = (candidate) => listDeploymentsNamed(input.config, candidate, input.options.signal);
+  let name = input.deploymentName;
+  const [listError, firstRows] = await catchError(lookUp(name ?? input.defaultName));
+  const aborted = abortedLookup(input.options.signal, listError, "Could not check whether the deployment name is taken");
+  if (aborted)
+    return aborted;
+  if (listError || !firstRows) {
+    if (!allowedToSkipNameCheck(listError, input.config)) {
+      const classified = listError instanceof SolutionDeploymentsError ? listError.errorCode : undefined;
+      const denied = classified === "permission_denied";
+      const needsUserLogin = listError instanceof SolutionDeploymentsError && listError.refusal === "needs-user-session";
+      return failure("service-error", `Could not check whether the deployment name is taken: ${listError instanceof Error ? listError.message : "unknown error"}`, needsUserLogin ? "This server's deployment search reads user logins only, so an " + "application login cannot check the name is free. Run the deploy with " + "a user login ('uip login'), or upgrade the existing deployment with " + "--action upgrade." : denied ? "A fresh install needs to read the Automation Solutions deployments to " + "check the name is free — Automation Solutions adopts a deployment whose " + "name it reuses. Ask for permission to list solution deployments in this " + "tenant, or upgrade the existing deployment with --action upgrade." : "Retry the deploy. If it keeps failing, pass --deployment-name with a name you know is free, or upgrade the existing deployment with --action upgrade.", {
+        errorCode: classified ?? "server_error",
+        retry: denied ? "RetryWillNotFix" : "RetryLater"
+      });
+    }
+    return unchanged;
+  }
+  let deployments = firstRows;
+  for (let attempt = 0;attempt < NAME_ATTEMPTS; attempt += 1) {
+    const effective = name ?? input.defaultName;
+    const newest = newestDeployment(deployments);
+    const held = newest && isCompletedUninstall(newest) ? undefined : newest;
+    if (!held) {
+      return { ...unchanged, deploymentName: name };
+    }
+    const verdict = upgradeInPlaceVerdict(held, input.defaultName, input.packageVersion);
+    if (!canPrompt()) {
+      return nonInteractiveNameConflict(held, effective, verdict, input);
+    }
+    const choice = await askAboutNameCollision(held, effective, verdict, input);
+    if (choice === "abort") {
+      return failure("name-conflict", "Deploy canceled: the deployment name is already taken.", "Pass a --deployment-name that is not in use, or --action upgrade to " + "upgrade the deployment that holds it.");
+    }
+    if (choice === "upgrade" && verdict.ok) {
+      return upgradeHeldDeployment(held, effective, input);
+    }
+    const entered = await input.prompts.askText("New deployment name", await freeNameNear(input.defaultName, lookUp));
+    name = entered?.trim() || undefined;
+    const next = await lookUpAgain(lookUp, name ?? input.defaultName, input);
+    if (!next.ok)
+      return next;
+    deployments = next.rows;
+  }
+  return failure("name-conflict", `Still no free deployment name after ${NAME_ATTEMPTS} tries.`, "Pass one that is not in use with --deployment-name <name>.");
+}
+function allowedToSkipNameCheck(error, config) {
+  const code = error instanceof SolutionDeploymentsError ? error.errorCode : undefined;
+  if (code === "permission_denied" || code === "authentication_required") {
+    return isExternalApplication(config);
+  }
+  return code === "configuration_error" && config.sendScopeIds;
+}
+function isExternalApplication(config) {
+  if (config.actorType !== "Application")
+    return false;
+  if (config.actorSubType)
+    return config.actorSubType === "service.external";
+  if (config.authFlow) {
+    return config.authFlow === "client_credentials" || config.authFlow === "federated_credentials";
+  }
+  return true;
+}
+async function nonInteractiveNameConflict(held, effective, verdict, input) {
+  const parentKey = verdict.ok ? await parentFolderKeyOf(held, input) : undefined;
+  return failure("name-conflict", `A deployment named "${effective}" already exists on this tenant ` + `(${held.packageName} v${held.packageVersion} in ${held.folderPath ?? "an unknown folder"}).` + (verdict.reason ? ` ${verdict.reason}` : ""), verdict.ok ? `Deployment names are unique per tenant. Pass --deployment-name <name> to install ` + `alongside it, or --action upgrade --deployment-name "${held.name}" ` + `--folder-key ${parentKey ?? "<key of the folder it was deployed into>"} to update the one that is already there.` : "Deployment names are unique per tenant. Pass --deployment-name <name> to install alongside it.");
+}
+function askAboutNameCollision(held, effective, verdict, input) {
+  return input.prompts.resolveNameCollision({
+    name: effective,
+    solution: held.packageName || "(unknown)",
+    version: held.packageVersion || "(unknown)",
+    folder: held.folderPath ?? held.installedRootFolderKey ?? "(unknown)",
+    status: held.activationStatus ?? held.operationStatus ?? "(unknown)",
+    canUpgradeInPlace: verdict.ok,
+    ...verdict.reason ? { reason: verdict.reason } : {}
+  });
+}
+async function upgradeHeldDeployment(held, effective, input) {
+  const parentKey = await parentFolderKeyOf(held, input);
+  if (parentKey === undefined) {
+    return failure("name-conflict", `The deployment "${held.name}" holds this name, but the folder it was deployed into ` + `(${held.folderPath ?? "unknown"}) could not be matched to a folder key.`, `Run the upgrade directly: --action upgrade --deployment-name "${held.name}" ` + "--folder-key <key of that folder>.");
+  }
+  const action = await pivotDirection(input, held);
+  if (typeof action !== "string")
+    return action;
+  writeProgress(`  Continuing — this will ${action} the existing deployment "${effective}".`);
+  return {
+    ok: true,
+    action,
+    deploymentName: held.name,
+    target: { folderKey: parentKey },
+    targetLabel: labelFor(input.folderLabels, parentKey)
+  };
+}
+async function lookUpAgain(lookUp, name, input) {
+  const [error, rows] = await catchError(lookUp(name));
+  const context = `Could not check whether the deployment name "${name}" is taken`;
+  const aborted = abortedLookup(input.options.signal, error, context);
+  if (aborted)
+    return aborted;
+  if (error || !rows) {
+    return failure("service-error", `${context}: ${error instanceof Error ? error.message : "unknown error"}`, "Retry the deploy. If it keeps failing, pass --deployment-name with a name you know is free.", {
+      errorCode: error instanceof SolutionDeploymentsError ? error.errorCode ?? "server_error" : "server_error",
+      retry: "RetryLater"
+    });
+  }
+  return { ok: true, rows };
+}
+async function freeNameNear(base, lookUp) {
+  for (let suffix = 2;suffix < 2 + NAME_ATTEMPTS; suffix += 1) {
+    const candidate = `${base}-${suffix}`;
+    const [error, rows] = await catchError(lookUp(candidate));
+    if (error || !rows)
+      break;
+    if (rows.length === 0)
+      return candidate;
+  }
+  return `${base}-2`;
+}
+async function parentFolderKeyOf(held, input) {
+  if (!held.folderPath)
+    return;
+  const wanted = held.folderPath.toLowerCase();
+  const inLabels = keyForPath(input.folderLabels, wanted);
+  if (inLabels)
+    return inLabels;
+  const loaded = await loadFolderLabels(input.config, input.listFolders, input.options.signal);
+  if (!loaded.ok)
+    return;
+  for (const [key, path] of loaded.labels)
+    input.folderLabels.set(key, path);
+  return keyForPath(loaded.labels, wanted);
+}
+function upgradeInPlaceVerdict(held, solutionName, packageVersion) {
+  const theirs = held.packageName.trim().toLowerCase();
+  const ours = solutionName.trim().toLowerCase();
+  if (theirs && ours && theirs !== ours) {
+    return {
+      ok: false,
+      reason: `It belongs to a different solution ("${held.packageName}") — it cannot be upgraded to this package.`
+    };
+  }
+  const version = held.packageVersion.trim();
+  if (!version) {
+    return {
+      ok: false,
+      reason: "Its current version is unknown — it cannot be upgraded from here."
+    };
+  }
+  if (version === packageVersion) {
+    return {
+      ok: false,
+      reason: `It is already at ${packageVersion} — there is nothing to upgrade.`
+    };
+  }
+  if (!isInstalledDeployment(held) || !held.installedRootFolderKey) {
+    return {
+      ok: false,
+      reason: "It never finished installing — it cannot be upgraded. Remove it in " + "Automation Solutions, or deploy under a different name."
+    };
+  }
+  return { ok: true };
+}
+async function pivotDirection(input, held) {
+  const [error, nav] = await catchError(listPackageVersions(input.config, input.packageName, {
+    stage: input.stage,
+    anchorVersion: held.packageVersion,
+    signal: input.options.signal
+  }));
+  const aborted = abortedLookup(input.options.signal, error, "Could not list package versions");
+  if (aborted)
+    return aborted;
+  if (error || !nav) {
+    return toDeployFailure(error, `Could not list the versions of ${input.packageName} to tell an upgrade ` + "from a downgrade");
+  }
+  const versions = normalizeVersions(nav);
+  const match = versions.find((version) => version.version === input.packageVersion);
+  if (!match) {
+    writeProgress("  Could not tell whether this is an upgrade or a downgrade — submitting it as " + "an upgrade (the service validates the transition).");
+    return "upgrade";
+  }
+  const gate = validateRequestedVersion(match.version, versions);
+  if (typeof gate !== "string")
+    return gate;
+  return match.relation === "previous" ? "downgrade" : "upgrade";
+}
+
+// src/services/target/package-name.ts
+async function resolvePackageName(config, options, prompts, stage) {
+  if (options.packageName)
+    return options.packageName;
+  if (!canPrompt()) {
+    return missingOption("A package name", "--package-name <name>");
+  }
+  const vertical = await resolveVertical(config, options, prompts);
+  if (typeof vertical !== "string")
+    return vertical;
+  const [error, packages] = await catchError(listPackages(config, vertical, stage, options.signal));
+  if (error)
+    return toDeployFailure(error, "Could not list packages");
+  if (!packages || packages.length === 0) {
+    return failure("unknown-package", `No packages are published for vertical "${vertical}".`, "Check the vertical name with --vertical, or ask the package's author whether it has been published.");
+  }
+  return prompts.pickOne("Package", packages.map((pkg) => ({
+    name: pkg.currentVersion ? `${pkg.displayName ?? pkg.packageName} (latest: ${pkg.currentVersion})` : pkg.displayName ?? pkg.packageName,
+    value: pkg.packageName
+  })));
+}
+async function resolveVertical(config, options, prompts) {
+  const [error, verticals] = await catchError(listVerticals(config, options.signal));
+  if (error)
+    return toDeployFailure(error, "Could not list verticals");
+  const available = verticals ?? [];
+  if (options.vertical) {
+    const matched = available.find((candidate) => candidate.toLowerCase() === options.vertical?.toLowerCase());
+    if (!matched) {
+      return invalidOption(`Unknown vertical "${options.vertical}".`, available.length > 0 ? `Available verticals: ${available.join(", ")}.` : "The service reports no verticals for this tenant.");
+    }
+    return matched;
+  }
+  if (available.length === 0) {
+    return failure("unknown-package", "The service reports no verticals for this tenant.", "Check that the tenant is onboarded to Vertical Solutions.");
+  }
+  if (available.length === 1)
+    return available[0];
+  return prompts.pickOne("Vertical", available.map((vertical) => ({ name: vertical, value: vertical })));
+}
+
+// src/services/target/target-folder.ts
+async function resolveTargetFolder(config, decision, options, prompts, listFolders, folderIndex) {
+  const folderLabels = folderIndex.labels;
+  if (decision.action !== "install") {
+    const key = decision.deployment.folderKey;
+    return {
+      ok: true,
+      target: { folderKey: key },
+      label: labelFor(folderLabels, key)
+    };
+  }
+  if (options.folderPath !== undefined) {
+    if (!options.folderPath.trim()) {
+      return invalidOption("--folder-path cannot be empty.", "Pass a folder path or use --folder-key <guid>.");
+    }
+    return resolveFolderPath(config, options, listFolders, folderIndex);
+  }
+  const folderKey = options.folderKey?.trim();
+  if (options.folderKey !== undefined && !folderKey) {
+    return invalidOption("--folder-key cannot be empty.", "Drop --folder-key, or pass the folder's key.");
+  }
+  if (folderKey) {
+    return folderByKey(folderKey, folderIndex);
+  }
+  if (!canPrompt()) {
+    return missingOption("A target folder", "--folder-path <path> or --folder-key <guid>");
+  }
+  const [error, folders] = folderIndex.read ? [undefined, folderIndex.folders] : await catchError(listFolders(config, options.signal));
+  const aborted = abortedLookup(options.signal, error, FOLDER_LIST_CONTEXT);
+  if (aborted)
+    return aborted;
+  if (error || !folders) {
+    const typed = await prompts.askText("Target folder name (could not list folders)");
+    return typed?.trim() ? {
+      ok: true,
+      target: { folderName: typed.trim() },
+      label: typed.trim()
+    } : missingOption("A target folder", "--folder-path <path> or --folder-key <guid>");
+  }
+  const selectable = folders.filter((folder) => folder.kind !== "Solution");
+  if (selectable.length === 0) {
+    return failure("invalid-option", "This tenant has no Orchestrator folder to install into.", "Create a folder in Orchestrator first, then re-run the deploy.");
+  }
+  const picked = await prompts.pickOne("Target folder", selectable.map((folder) => ({ name: folder.path, value: folder.key })));
+  const chosen = selectable.find((folder) => folder.key === picked);
+  return {
+    ok: true,
+    target: { folderKey: picked },
+    label: chosen?.path ?? picked
+  };
+}
+function folderByKey(folderKey, folderIndex) {
+  const folders = folderIndex.folders;
+  if (!folders) {
+    writeProgress(`  Could not read the Orchestrator folders to check --folder-key ${folderKey}; ` + "sending it as given.");
+    return {
+      ok: true,
+      target: { folderKey },
+      label: labelFor(folderIndex.labels, folderKey)
+    };
+  }
+  const match = folders.find((folder) => sameKey(folder.key, folderKey));
+  if (!match) {
+    return invalidOption(`--folder-key ${folderKey} matches no Orchestrator folder in this tenant.`, "Pass the key of an existing folder, or name it with --folder-path <path>.");
+  }
+  if (match.kind === "Solution") {
+    return invalidOption(`--folder-key ${folderKey} is the Solution folder "${match.path}", which ` + "Automation Solutions owns.", "Pass the folder the solution should install UNDER — a Solution folder is " + "created beneath it.");
+  }
+  return { ok: true, target: { folderKey: match.key }, label: match.path };
+}
+async function resolveFolderPath(config, options, listFolders, folderIndex) {
+  const wanted = (options.folderPath ?? "").trim();
+  let folders = folderIndex.folders;
+  let error;
+  if (!folders && folderIndex.read) {
+    return unreadableFolderPath(wanted, options, undefined);
+  }
+  if (!folders) {
+    [error, folders] = await catchError(listFolders(config, options.signal));
+    const aborted = abortedLookup(options.signal, error, FOLDER_LIST_CONTEXT);
+    if (aborted)
+      return aborted;
+  }
+  if (error || !folders) {
+    return unreadableFolderPath(wanted, options, error);
+  }
+  const lower = wanted.toLowerCase();
+  const byPath = folders.filter((folder) => folder.path.toLowerCase() === lower);
+  const matches = byPath.length > 0 ? byPath : folders.filter((folder) => folder.displayName.toLowerCase() === lower);
+  if (matches.length === 0) {
+    return invalidOption(`--folder-path ${wanted} matches no Orchestrator folder in this tenant.`, "Pass the full path as Orchestrator shows it (for example Shared/Production), " + "or the folder's key with --folder-key <guid>.");
+  }
+  if (matches.length > 1) {
+    return invalidOption(`--folder-path ${wanted} matches ${matches.length} folders: ` + `${matches.map((folder) => folder.path).join(", ")}.`, "Pass the full path of the one you mean, or --folder-key <guid>.");
+  }
+  const match = matches[0];
+  if (options.folderKey && !sameKey(match.key, options.folderKey)) {
+    return invalidOption(`--folder-path ${wanted} (${match.key}) and --folder-key ${options.folderKey} ` + "name different folders.", "Drop one of the two, or correct it so both point at the same folder.");
+  }
+  if (match.kind === "Solution") {
+    return invalidOption(`--folder-path ${wanted} is a Solution folder, which Automation Solutions owns.`, "Pass the folder the solution should install under — a Solution folder is created " + "beneath it.");
+  }
+  return { ok: true, target: { folderKey: match.key }, label: match.path };
+}
+function unreadableFolderPath(wanted, options, error) {
+  const reason = error?.message ?? "unknown error";
+  if (options.folderKey) {
+    writeProgress(`  Could not read the Orchestrator folders to check --folder-path ${wanted} ` + `against --folder-key ${options.folderKey} (${reason}); using the key.`);
+    return {
+      ok: true,
+      target: { folderKey: options.folderKey },
+      label: wanted
+    };
+  }
+  if (!wanted.includes("/")) {
+    writeProgress(`  Could not read the Orchestrator folders to check --folder-path ${wanted} ` + `(${reason}); sending it to the service as a folder name.`);
+    return { ok: true, target: { folderName: wanted }, label: wanted };
+  }
+  return failure("service-error", `Could not read the Orchestrator folders to resolve --folder-path ${wanted}: ${reason}`, "Pass the folder's key with --folder-key <guid> instead, or give this login the " + "right to read Orchestrator folders.", { errorCode: "server_error", retry: "RetryLater" });
+}
+
+// src/services/resolve-target.ts
+var DEFAULT_STAGE = "stable";
+async function resolveDeployTarget(config, options, prompts, listFolders = listAllFolders) {
+  const stage = options.stage ?? DEFAULT_STAGE;
+  const packageName = await resolvePackageName(config, options, prompts, stage);
+  if (typeof packageName !== "string")
+    return packageName;
+  const [lookupError, existingAll] = await catchError(findCurrentDeployments(config, packageName, options.signal));
+  if (lookupError) {
+    return toDeployFailure(lookupError, "Could not list current deployments");
+  }
+  const existing = (existingAll ?? []).filter((deployment) => deployment.status === "Installed");
+  const folderIndex = existing.length > 0 || options.folderKey !== undefined ? await loadFolderLabels(config, listFolders, options.signal) : { ok: true, labels: new Map, read: false };
+  if (!folderIndex.ok)
+    return folderIndex;
+  const folderLabels = folderIndex.labels;
+  const decision = await resolveAction(existing, options, prompts, folderIndex);
+  if (!decision.ok)
+    return decision;
+  const target = await resolveTargetFolder(config, decision, options, prompts, listFolders, folderIndex);
+  if (!target.ok)
+    return target;
+  const resolved = await resolveVersion(config, packageName, stage, decision, options, prompts);
+  if (!resolved.ok)
+    return resolved;
+  const { version, versions, picked: versionPicked } = resolved;
+  const [manifestError, manifest] = await catchError(getManifest(config, packageName, version, options.signal));
+  if (manifestError || !manifest) {
+    return toDeployFailure(manifestError, `Could not read the manifest of ${packageName} ${version}`);
+  }
+  const provisionalAction = settleProvisionalAction(decision.action, decision.explicit, versionPicked, version, versions);
+  if (typeof provisionalAction !== "string")
+    return provisionalAction;
+  const defaultName = solutionNameFromManifest(manifest) || packageName;
+  const named = provisionalAction === "install" ? await resolveDeploymentName(defaultName, target.label, options, prompts) : upgradeName(decision.deployment, options);
+  const settled = await settleNameCollision({
+    config,
+    existing,
+    listFolders,
+    action: provisionalAction,
+    deploymentName: named,
+    defaultName,
+    packageName,
+    packageVersion: version,
+    stage,
+    target,
+    folderLabels,
+    options,
+    prompts
+  });
+  if (!settled.ok)
+    return settled;
+  return {
+    ok: true,
+    packageName,
+    packageVersion: version,
+    action: settled.action,
+    target: settled.target,
+    targetLabel: settled.targetLabel,
+    manifest,
+    existing: decision.deployment,
+    deploymentName: settled.deploymentName
+  };
+}
+
+// src/services/deploy/prepare-submit.ts
+async function prepareSubmit(config, options, deps) {
+  const target = await resolveDeployTarget(config, options, deps.target);
+  if (!target.ok)
+    return target;
+  const tenantResources = findTenantResources(target.manifest);
+  if (tenantResources.length > 0) {
+    return failure("tenant-resources-declared", `${target.packageName} ${target.packageVersion} provisions tenant-level resources, ` + `which 'uip vss deploy' does not deploy:
+` + describeTenantResources(tenantResources), "Deploying it here would leave those resources unprovisioned while reporting success. " + "Use the vertical-deploy-cli for this package until tenant-level resources are supported.");
+  }
+  const collected = await collectConfigurations(target.manifest, { config: options.config, configFile: options.configFile }, deps.configuration);
+  if (!collected.ok)
+    return collected;
+  for (const warning of collected.warnings)
+    writeWarning(warning);
+  const resourceConfigurations = await buildDeployConfigPayload(options, target.manifest, target.action === "install", deps);
+  if (!resourceConfigurations.ok)
+    return resourceConfigurations;
+  const request = {
+    packageName: target.packageName,
+    packageVersion: target.packageVersion,
+    action: target.action,
+    target: target.target
+  };
+  if (Object.keys(collected.configurations).length > 0) {
+    request.configurations = collected.configurations;
+  }
+  if (resourceConfigurations.value.payload.length > 0) {
+    request.resourceConfigurations = resourceConfigurations.value.payload;
+  }
+  if (target.deploymentName)
+    request.deploymentName = target.deploymentName;
+  addIdentityFields(request, config);
+  return {
+    ok: true,
+    request,
+    manifest: target.manifest,
+    targetLabel: target.targetLabel,
+    resources: resourceConfigurations.value.sources
+  };
+}
+function addIdentityFields(request, config) {
+  if (config.actor)
+    request.uploadedBy = config.actor;
+  if (config.organizationName) {
+    request.organizationName = config.organizationName;
+  }
+  if (config.tenantName)
+    request.tenantName = config.tenantName;
+  if (!config.sendScopeIds)
+    return;
+  if (config.organizationId)
+    request.organizationId = config.organizationId;
+  if (config.tenantId)
+    request.tenantId = config.tenantId;
+}
+async function buildDeployConfigPayload(options, manifest, isFreshInstall, deps) {
+  const [discoverError, path] = await catchError(discoverDeployConfig(options.resourceConfig));
+  if (discoverError) {
+    return invalidOption(discoverError.message, "Check the path, or drop --resource-config to use ./deploy-config.json when it exists.");
+  }
+  let file;
+  if (path !== undefined) {
+    const [loadError, loaded] = await catchError(loadDeployConfig(path));
+    if (loadError || !loaded) {
+      return invalidOption(loadError?.message ?? `Could not read ${path}.`, "Fix the file, or point --resource-config at a different one.");
+    }
+    file = loaded;
+  }
+  const collected = await collectDeclaredConfiguration({
+    manifest,
+    file,
+    isFreshInstall,
+    prompts: deps.configuration
+  });
+  for (const warning of collected.warnings)
+    writeWarning(warning);
+  return {
+    ok: true,
+    value: {
+      payload: collected.payload,
+      sources: { path: file?.path, fromFile: collected.fromFile }
+    }
+  };
+}
+function summarize(prepared) {
+  const { request, targetLabel, resources } = prepared;
+  const configured = Object.keys(request.configurations ?? {});
+  const lines = [
+    `Package:  ${request.packageName} ${request.packageVersion}`,
+    `Action:   ${request.action ?? "install"}`,
+    `Target:   folder "${targetLabel}"`
+  ];
+  if (request.deploymentName) {
+    lines.push(`Name:     ${request.deploymentName}`);
+  }
+  if (configured.length > 0) {
+    lines.push(`Config:   ${configured.join(", ")}`);
+  }
+  for (const resource of request.resourceConfigurations ?? []) {
+    const supplied = resources.fromFile.get(resource.name.toLowerCase()) ?? new Set;
+    const keys = Object.keys(resource.configuration);
+    const fromFile = keys.filter((key) => supplied.has(key));
+    let source = "";
+    if (resources.path && fromFile.length === keys.length) {
+      source = ` (from ${resources.path})`;
+    } else if (resources.path && fromFile.length > 0) {
+      source = ` (${fromFile.join(", ")} from ${resources.path}; the rest typed)`;
+    }
+    lines.push(`Resource: ${resource.name}: ${keys.join(", ")}${source}`);
+  }
+  return lines.join(`
+`);
+}
+
+// src/services/deploy/watch-to-completion.ts
+async function watchToCompletion(config, job, options, deps, submitted) {
+  const { serviceUrl, manifest, sentResourceConfigurations, deploymentName } = submitted;
+  const routing = routingFlags(options);
+  const outcome = await watchDeployJob(watchOptionsFrom(options, {
+    jobId: job.id,
+    config,
+    serviceUrl,
+    prompt: deps.watch,
+    sentResourceConfigurations
+  }));
+  switch (outcome.kind) {
+    case "detached":
+    case "timeout":
+    case "lost-contact":
+      return stoppedWatching(outcome, job.id, options.timeout, options);
+    case "succeeded": {
+      writeSuccessSummary(outcome.job, outcome.lastLogMessage);
+      const [extraError, extra] = await catchError(finalizeSucceededJob({
+        config: outcome.config ?? config,
+        job: outcome.job,
+        deploymentName,
+        manifest,
+        options,
+        deps,
+        serviceUrl
+      }));
+      if (extraError) {
+        writeWarning(`The deploy succeeded. Preparing the seed workspace afterwards failed ` + `(${extraError.message}), so nothing was seeded: run 'uip vss deploy seed' ` + "when you are ready.");
+      }
+      return {
+        ok: true,
+        outcome: "succeeded",
+        job: outcome.job,
+        failedSteps: outcome.failedSteps,
+        ...extra ?? {}
+      };
+    }
+    case "paused":
+      return failure("job-paused", `Job ${job.id} is paused: it needs ${describePauseKind(outcome.actionKind)}.` + (outcome.url ? `
+${forDisplay(outcome.url)}` : ""), pauseInstructions(outcome.actionKind, `uip vss deploy resume ${job.id}${routing}`), { errorCode: pauseErrorCode(outcome.actionKind) });
+    case "failed":
+      return failure("job-failed", `Job ${job.id} failed` + (outcome.job.error?.step ? ` at step ${forDisplay(outcome.job.error.step)}` : "") + `: ${forDisplayIfSet(outcome.job.error?.message) ?? "unknown error"}`, `The job is checkpointed. Retry from the last successful step with: uip vss deploy resume ${job.id}${routing}`);
+    case "canceled":
+      writeProgress(`
+Deployment canceled.`);
+      writeStepSummary(outcome.job);
+      return failure("job-canceled", `Job ${job.id} was canceled.`, `Start again with a new deploy, or inspect it with: uip vss deploy status ${job.id}${routing}`);
+    case "rejected":
+      return toDeployFailure(outcome.error, `Could not ${outcome.attempting ?? "read"} job ${job.id}`, {
+        notFound: "job",
+        attempting: outcome.attempting ?? "read",
+        jobId: job.id,
+        routing: options
+      });
+  }
+}
+
+// src/services/deploy-service.ts
+async function runDeploy(options, deps) {
+  const blank = rejectBlankOptions(options);
+  if (blank)
+    return blank;
+  const serviceUrl = readServiceUrl(options.serviceUrl, options.tenant);
+  if (!serviceUrl.ok)
+    return serviceUrl;
+  const seedWithoutWait = rejectSeedWithoutWait(options);
+  if (seedWithoutWait)
+    return seedWithoutWait;
+  const [authError, config] = await catchError(createVssConfig({
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    serviceUrl: serviceUrl.value
+  }));
+  if (authError || !config)
+    return credentialsFailure(authError);
+  const prepared = await prepareSubmit(config, options, deps);
+  if (!prepared.ok)
+    return prepared;
+  const { request, manifest } = prepared;
+  if (options.yes !== true) {
+    if (!canPrompt()) {
+      return failure("missing-option", "Confirmation is required before a deploy runs.", "Re-run with --yes to confirm, or run from an interactive terminal to be asked.", {
+        result: RESULTS.ValidationError,
+        errorCode: "invalid_argument"
+      });
+    }
+    if (!await deps.confirmProceed(summarize(prepared))) {
+      return failure("declined", "Deploy canceled before submitting.", "Nothing was sent to the service. Run the command again when the " + "summary is what you want, or pass --yes to skip this question.");
+    }
+  }
+  const [submitError, job] = await catchError(withCapacityRetry(() => submitDeployJob(config, request, options.signal), "the submit", undefined, options.signal));
+  if (submitError) {
+    if (options.signal?.aborted === true || !(submitError instanceof VssApiError)) {
+      return failure("lost-contact", `The submit of ${request.packageName} ${request.packageVersion} ${options.signal?.aborted === true ? "was interrupted before the service answered" : `did not get an answer the CLI could read (${submitError.message})`}, so it is not known whether a deploy job was created.`, checkBeforeResubmitting(options));
+    }
+    return toDeployFailure(submitError, "Could not submit the deploy job", {
+      routing: options,
+      attempting: "submit"
+    });
+  }
+  writeProgress(`Deploy job ${job.id} accepted and running.`);
+  if (options.wait === false) {
+    return { ok: true, outcome: "submitted", job };
+  }
+  return watchToCompletion(config, job, options, deps, {
+    serviceUrl: serviceUrl.value,
+    manifest,
+    sentResourceConfigurations: (request.resourceConfigurations ?? []).length > 0,
+    deploymentName: request.deploymentName
+  });
+}
+export {
+  runDeploy
+};
+
+//# debugId=C7ED42996FA9E56D64756E2164756E21