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

package/dist/job-commands-azgbrbdb.js

@@ -0,0 +1,23 @@
+import {
+  credentialsFailure,
+  emitFailure,
+  exitIfCallerAborted,
+  readServiceUrl,
+  resolveConfigOrFail
+} from "./tool-p589v2r5.js";
+import"./tool-xd2ejt3h.js";
+import"./tool-38ad77wd.js";
+import"./tool-h4f967yd.js";
+import"./tool-rr9fensp.js";
+import"./tool-pz9qm3dv.js";
+import"./tool-hdxtgckw.js";
+import"./tool-1yh8g550.js";
+export {
+  credentialsFailure,
+  emitFailure,
+  exitIfCallerAborted,
+  readServiceUrl,
+  resolveConfigOrFail
+};
+
+//# debugId=62E8A0C7030A6A9164756E2164756E21

package/dist/job-output-t43hzj1f.js

@@ -0,0 +1,36 @@
+import {
+  collapseRowProblems,
+  failedStepsOf,
+  formatSkippedSteps,
+  formatStepSummary,
+  inExecutionOrder,
+  logLineText,
+  runningStepOf,
+  stepLabel,
+  writeJobLogLine,
+  writeProgress,
+  writeStepSummary,
+  writeSuccessSummary,
+  writeWarning
+} from "./tool-v15vxc4x.js";
+import"./tool-rr9fensp.js";
+import"./tool-pz9qm3dv.js";
+import"./tool-hdxtgckw.js";
+import"./tool-1yh8g550.js";
+export {
+  collapseRowProblems,
+  failedStepsOf,
+  formatSkippedSteps,
+  formatStepSummary,
+  inExecutionOrder,
+  logLineText,
+  runningStepOf,
+  stepLabel,
+  writeJobLogLine,
+  writeProgress,
+  writeStepSummary,
+  writeSuccessSummary,
+  writeWarning
+};
+
+//# debugId=6A5739E4BBA0F27064756E2164756E21

package/dist/prompts-dtgt183n.js

@@ -0,0 +1,260 @@
+import {
+  dist_default1 as dist_default,
+  dist_default2,
+  dist_default3,
+  dist_default4
+} from "./tool-r1ewa0tf.js";
+import {
+  forDisplay,
+  forDisplayIfSet
+} from "./tool-rr9fensp.js";
+import {
+  ScreenLogger
+} from "./tool-pz9qm3dv.js";
+import"./tool-hdxtgckw.js";
+import {
+  __require
+} from "./tool-1yh8g550.js";
+
+// src/services/prompts.ts
+var targetPrompts = {
+  async pickOne(label, choices) {
+    return dist_default4({
+      message: `Select ${label}`,
+      choices: choices.map((choice) => ({
+        name: forDisplay(choice.name),
+        value: choice.value,
+        disabled: choice.disabled
+      }))
+    });
+  },
+  async askText(label, defaultValue) {
+    return dist_default2({
+      message: forDisplay(label),
+      default: forDisplayIfSet(defaultValue)
+    });
+  },
+  async chooseDeployMode(existing) {
+    const summary = existing.map(({ deployment, folderLabel }) => `v${deployment.packageVersion} in ${folderLabel}`).join(", ");
+    return dist_default4({
+      message: `Already deployed: ${forDisplay(summary)}. What would you like to do?`,
+      choices: [
+        {
+          name: "Upgrade or downgrade the existing deployment",
+          value: "existing"
+        },
+        {
+          name: "Fresh install into another folder",
+          value: "fresh"
+        }
+      ]
+    });
+  },
+  async confirmSteppingStone(step) {
+    return dist_default({
+      message: forDisplay(`Upgrading from ${step.installed} to ${step.wanted} is not possible: ` + `there are breaking changes in between.
+` + `  You can upgrade to ${step.stone} now, then re-run this command ` + `to reach ${step.wanted}.
+` + `Deploy ${step.stone} instead?`),
+      default: true
+    });
+  },
+  async resolveNameCollision(held) {
+    const choices = [
+      ...held.canUpgradeInPlace ? [
+        {
+          name: `Upgrade the existing "${forDisplay(held.name)}" instead`,
+          value: "upgrade"
+        }
+      ] : [],
+      {
+        name: "Install alongside it under a different name",
+        value: "rename"
+      },
+      { name: "Abort", value: "abort" }
+    ];
+    return dist_default4({
+      message: forDisplay(`A deployment named "${held.name}" already exists on this tenant.
+` + `  Solution: ${held.solution} v${held.version}
+` + `  Folder:   ${held.folder}
+` + `  Status:   ${held.status}
+` + "  Deployment names are unique per tenant — installing under this name " + `would target the existing deployment instead of creating a new one.
+` + (held.reason ? `  ${held.reason}
+` : "") + "What would you like to do?"),
+      choices
+    });
+  }
+};
+var configurationPrompts = {
+  async askValue(key, options) {
+    const message = forDisplay(options.description ? `${options.description} (${key})` : key);
+    if (options.secret) {
+      return dist_default3({ message, mask: true });
+    }
+    return dist_default2({
+      message,
+      default: forDisplayIfSet(options.defaultValue),
+      ...options.validate ? { validate: options.validate } : {}
+    });
+  }
+};
+function createWatchPrompts() {
+  return {
+    async waitForActionRequired(kind, _url, signal) {
+      await dist_default2({
+        message: kind === "connection_setup" ? "Press Enter once the connections are authorized" : "Press Enter once the step above is complete"
+      }, { signal });
+    },
+    async confirmResume(job, signal) {
+      return dist_default({
+        message: `Retry job ${job.id} from the last checkpoint now?`,
+        default: true
+      }, { signal });
+    },
+    async confirmOpenBrowser(page, signal) {
+      return dist_default({
+        message: `Open the ${page.toLowerCase()} page in the browser?`,
+        default: true
+      }, { signal });
+    },
+    async openUrl(url) {
+      const { getFileSystem } = await import("./index-ngs0a2he.js");
+      await getFileSystem().utils.open(url);
+    }
+  };
+}
+async function confirmProceed(summary) {
+  return dist_default({
+    message: `${forDisplay(summary)}
+Proceed with the deploy?`,
+    default: true
+  });
+}
+function progress(line) {
+  ScreenLogger.progress(forDisplay(line));
+}
+async function confirmSeed(offer) {
+  progress(`
+Seed files: ${offer.workspaceDir}`);
+  progress("  (edit the CSVs there to change what gets seeded)");
+  progress(`Target: ${offer.organizationName ?? "?"} / ${offer.tenantName ?? "?"} — ${offer.scope}`);
+  for (const entity of offer.entities) {
+    progress(`  ${entity.name}: ${entity.rows} row(s) — strategy: ${entity.strategy}`);
+  }
+  return dist_default({
+    message: "Seed Data Fabric data now?",
+    default: true
+  });
+}
+var seedPrompts = {
+  async pickOne(label, choices) {
+    return dist_default4({
+      message: forDisplay(`Select ${label}`),
+      choices: choices.map((choice) => ({
+        name: forDisplay(choice),
+        value: choice
+      }))
+    });
+  },
+  async confirmEntity(plan) {
+    const showDiff = await dist_default({
+      message: forDisplay(`${plan.entityName} has changes. Show diff?`),
+      default: true
+    });
+    const lines = [];
+    if (plan.toInsert.length > 0) {
+      lines.push(`
+${plan.entityName} — inserts:`, ...previewInserts(plan.toInsert));
+    }
+    if (plan.toUpdate.length > 0) {
+      lines.push(`
+${plan.entityName} — updates:`, ...previewChanges(plan.toUpdate));
+    }
+    if (plan.ignoredRows.length > 0) {
+      lines.push(`
+${plan.entityName} — changed rows left alone (insert strategy):`, ...previewChanges(plan.ignoredRows));
+    }
+    if (plan.toRepairAttachments.length > 0) {
+      lines.push(`
+${plan.entityName} — attachments to retry:`);
+      for (const row of plan.toRepairAttachments.slice(0, PREVIEW_ROWS)) {
+        lines.push(`  ${row.label}: ${Object.keys(row.attachments).join(", ")}`);
+      }
+    }
+    if (showDiff)
+      for (const line of lines)
+        progress(line);
+    const parts = [];
+    if (plan.toInsert.length > 0)
+      parts.push(`+${plan.toInsert.length} insert`);
+    if (plan.toUpdate.length > 0)
+      parts.push(`~${plan.toUpdate.length} update`);
+    if (plan.toRepairAttachments.length > 0)
+      parts.push(`${plan.toRepairAttachments.length} attachment retry`);
+    return dist_default({
+      message: forDisplay(`Seed ${plan.entityName} (${parts.join(", ")})?`),
+      default: true
+    });
+  },
+  async confirmClearOptional(diffs) {
+    progress(`
+Some optional fields are empty in the seed files but have values in Data Fabric:`);
+    for (const diff of diffs.slice(0, PREVIEW_ROWS * 2)) {
+      progress(`  ${diff.label}: ${diff.field} — Data Fabric has "${diff.live}"`);
+    }
+    if (diffs.length > PREVIEW_ROWS * 2) {
+      progress(`  … and ${diffs.length - PREVIEW_ROWS * 2} more`);
+    }
+    return dist_default({
+      message: "Clear these optional fields in Data Fabric?",
+      default: false
+    });
+  },
+  async createSdk(options) {
+    const { createSdk } = await import("./createSdk-2f9x47em.js");
+    return createSdk({ ...options, requireNames: true });
+  }
+};
+var PREVIEW_ROWS = 8;
+function previewInserts(rows) {
+  const lines = [];
+  for (const row of rows.slice(0, PREVIEW_ROWS)) {
+    lines.push(row.localId ? `  + insert (${row.localId}):` : "  + insert:");
+    for (const [field, text] of Object.entries(row.display)) {
+      lines.push(`      ${field}: ${text}`);
+    }
+  }
+  if (rows.length > PREVIEW_ROWS) {
+    lines.push(`  … and ${rows.length - PREVIEW_ROWS} more`);
+  }
+  return lines;
+}
+function previewChanges(rows) {
+  const lines = [];
+  for (const row of rows.slice(0, PREVIEW_ROWS)) {
+    lines.push(`  ~ Id: ${row.recordId ?? "?"} (${row.label})`);
+    const changes = row.changes ?? {};
+    for (const [field, text] of Object.entries(row.display)) {
+      const change = changes[field];
+      lines.push(change ? `      ${field}: ${change.from} → ${change.to}` : `      ${field}: ${text}`);
+    }
+    for (const [field, change] of Object.entries(changes)) {
+      if (field in row.display)
+        continue;
+      lines.push(`      ${field}: ${change.from} → ${change.to}`);
+    }
+  }
+  if (rows.length > PREVIEW_ROWS) {
+    lines.push(`  … and ${rows.length - PREVIEW_ROWS} more`);
+  }
+  return lines;
+}
+export {
+  configurationPrompts,
+  confirmProceed,
+  confirmSeed,
+  createWatchPrompts,
+  seedPrompts,
+  targetPrompts
+};
+
+//# debugId=A427ADC583EAC0CE64756E2164756E21

package/dist/resume-service-mqfnnzb5.js

@@ -0,0 +1,344 @@
+import {
+  FOLDER_PLACEHOLDER,
+  FOLDER_SCOPE_UNKNOWN_NOTE,
+  describePauseKind,
+  finalizeSucceededJob,
+  linkedOutHint,
+  linkedOutWorkspace,
+  namedJob,
+  pauseErrorCode,
+  pauseInstructions,
+  pauseRetry,
+  prepareWorkspaceWithoutManifest,
+  rejectSeedWithoutWait,
+  seedCommandFor,
+  seedYesFlag,
+  stoppedWatching
+} from "./tool-342sz3hm.js";
+import {
+  getManifest,
+  readSeedContext
+} from "./tool-e4qgwf9h.js";
+import {
+  packageDir
+} from "./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 {
+  finishedJobConflict,
+  knownJobStatus,
+  toDeployFailure
+} from "./tool-r2epw08s.js";
+import {
+  getDeployJob,
+  resumeDeployJob
+} from "./tool-mn1wkbhw.js";
+import"./tool-4z1dy1rn.js";
+import"./tool-87e2ps7f.js";
+import"./tool-38ad77wd.js";
+import {
+  routingFlags,
+  shellQuote
+} from "./tool-cag2z2d6.js";
+import {
+  failure
+} from "./tool-h4f967yd.js";
+import {
+  forDisplay,
+  forDisplayIfSet
+} from "./tool-rr9fensp.js";
+import"./tool-s04z9t80.js";
+import"./tool-vf2mgth0.js";
+import {
+  catchError
+} from "./tool-pz9qm3dv.js";
+import {
+  getFileSystem
+} from "./tool-hdxtgckw.js";
+import"./tool-1yh8g550.js";
+
+// src/services/resume/seed-advice.ts
+async function finishedJobSeedAdvice(config, finished, options) {
+  const job = namedJob(finished);
+  if (!job) {
+    return "The job carries no package name or version, so the workspace for it cannot be " + "named. Seed it with: uip vss deploy seed --package-name <name> " + `--package-version <version>${routingFlags(options)}${seedYesFlag(options)}`;
+  }
+  const scope = await finishedJobSeedScope(config, job, options.signal);
+  const [stateError, state] = await catchError(() => workspaceState(job, scope.tenantLevel));
+  if (state?.kind === "linked") {
+    const hint = linkedOutHint(job, scope.folderKey, options, state.target, scope.flag);
+    return `${state.message} ${hint}${scope.note}`;
+  }
+  const unread = stateError === undefined ? "" : ` The seed workspace could not be read (${stateError.message}), so whether it holds` + " this install's files is unknown: check it, or add --refresh to replace them.";
+  const command = seedCommandFor(job, scope.folderKey, options) + scope.flag + (state?.kind === "stale" ? " --refresh" : "") + seedYesFlag(options) + scope.note + folderDoubt(scope, state, job) + unread;
+  if (state?.kind === "file") {
+    return `The seed workspace ${state.dir} is not a directory, so 'uip vss deploy seed' would ` + `refuse it. Move it out of the way, then seed on its own with: ${command}`;
+  }
+  return `Seed on its own with: ${command}`;
+}
+function folderDoubt(scope, state, job) {
+  if (state?.kind !== "current")
+    return "";
+  if (state.recordedFolderKey === undefined)
+    return "";
+  if (scope.flag === FOLDER_PLACEHOLDER) {
+    return ` These files were filled in for folder ${state.recordedFolderKey}; add --refresh if you seed a different one.`;
+  }
+  const installed = job.installedFolderKey;
+  if (scope.tenantLevel === undefined && installed !== undefined && installed.toLowerCase() !== state.recordedFolderKey.toLowerCase()) {
+    return ` These files were filled in for folder ${state.recordedFolderKey}, but this job ` + `installed into folder ${installed}. If the package's entities are folder-scoped, ` + `add --folder-key ${shellQuote(installed)} --refresh.`;
+  }
+  return "";
+}
+async function finishedJobSeedScope(config, job, signal) {
+  const [error, manifest] = await catchError(getManifest(config, job.packageName, job.packageVersion, signal));
+  if (error || !manifest) {
+    return {
+      folderKey: undefined,
+      flag: "",
+      note: FOLDER_SCOPE_UNKNOWN_NOTE,
+      tenantLevel: undefined
+    };
+  }
+  const tenantLevel = Boolean(manifest.dataFabric?.schemaFilename);
+  if (!job.installedFolderKey) {
+    return {
+      folderKey: undefined,
+      flag: tenantLevel ? "" : FOLDER_PLACEHOLDER,
+      note: "",
+      tenantLevel
+    };
+  }
+  return {
+    folderKey: tenantLevel ? undefined : job.installedFolderKey,
+    flag: "",
+    note: "",
+    tenantLevel
+  };
+}
+async function workspaceState(job, tenantLevel) {
+  const linked = await linkedOutWorkspace(job.packageName);
+  if (linked)
+    return { kind: "linked", ...linked };
+  const dir = packageDir(job.packageName);
+  const stats = await getFileSystem().stat(dir);
+  if (!stats)
+    return { kind: "missing" };
+  if (!stats.isDirectory())
+    return { kind: "file", dir };
+  const context = await readSeedContext(dir);
+  const sameFolder = tenantLevel !== false || job.installedFolderKey === undefined || context?.folderKey === undefined || context.folderKey.toLowerCase() === job.installedFolderKey.toLowerCase();
+  const current = context?.packageName.trim().toLowerCase() === job.packageName.trim().toLowerCase() && context.packageVersion === job.packageVersion && sameFolder;
+  return {
+    kind: current ? "current" : "stale",
+    ...context?.folderKey ? { recordedFolderKey: context.folderKey } : {}
+  };
+}
+
+// src/services/resume-service.ts
+async function runResume(jobId, 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 [readError, existing] = await catchError(() => getDeployJob(config, jobId, options.signal));
+  if (readError || !existing) {
+    if (options.signal?.aborted === true) {
+      return { ok: true, outcome: "detached", jobId };
+    }
+    return toDeployFailure(readError, `Could not read job ${jobId}`, {
+      notFound: "job",
+      jobId,
+      routing: options
+    });
+  }
+  if (existing.status === "succeeded" || existing.status === "canceled") {
+    return await nothingToResume(config, existing, options);
+  }
+  const step = await restartOrAttach(config, existing, options);
+  if (step.kind === "done")
+    return step.result;
+  if (options.wait === false) {
+    return { ok: true, outcome: "submitted", job: step.job };
+  }
+  const outcome = await watchDeployJob(watchOptionsFrom(options, {
+    jobId,
+    config,
+    serviceUrl: serviceUrl.value,
+    prompt: deps.watch,
+    sentResourceConfigurations: existing.hasResourceConfigurations === true,
+    attached: step.attached
+  }));
+  return resumedOutcome(outcome, jobId, options.timeout, options, (done) => afterSuccess((outcome.kind === "succeeded" ? outcome.config : undefined) ?? config, done, options, deps, serviceUrl.value, step.attached));
+}
+async function resumedOutcome(outcome, jobId, timeoutSeconds, routing, aftercare) {
+  const flags = routingFlags(routing);
+  switch (outcome.kind) {
+    case "detached":
+    case "timeout":
+    case "lost-contact":
+      return stoppedWatching(outcome, jobId, timeoutSeconds, routing);
+    case "succeeded": {
+      writeSuccessSummary(outcome.job, outcome.lastLogMessage);
+      const [extraError, extra] = await catchError(aftercare(outcome.job));
+      if (extraError) {
+        writeWarning(`The job finished. 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 ${jobId} is paused again: it needs ${describePauseKind(outcome.actionKind)}.` + (outcome.url ? `
+${forDisplay(outcome.url)}` : ""), pauseInstructions(outcome.actionKind, `uip vss deploy resume ${jobId}${flags}`), {
+        retry: pauseRetry(outcome.actionKind),
+        errorCode: pauseErrorCode(outcome.actionKind)
+      });
+    case "failed":
+      return failure("job-failed", `Job ${jobId} failed again` + (outcome.job.error?.step ? ` at step ${forDisplay(outcome.job.error.step)}` : "") + `: ${forDisplayIfSet(outcome.job.error?.message) ?? "unknown error"}`, `The job is still checkpointed. Retry with: uip vss deploy resume ${jobId}${flags}`, { retry: "RetryLater" });
+    case "canceled":
+      writeProgress(`
+Deployment canceled.`);
+      writeStepSummary(outcome.job);
+      return failure("job-canceled", `Job ${jobId} was canceled.`, `Inspect it with: uip vss deploy status ${jobId}${flags}`);
+    case "rejected":
+      return toDeployFailure(outcome.error, `Could not ${outcome.attempting ?? "read"} job ${jobId}`, {
+        notFound: "job",
+        attempting: outcome.attempting ?? "read",
+        jobId,
+        routing
+      });
+  }
+}
+async function nothingToResume(config, job, options) {
+  if (options.seed !== true) {
+    return { ok: true, outcome: "nothing-to-resume", job };
+  }
+  const lead = `Job ${job.id} already ${job.status}, so there is nothing to resume and ` + "--seed has nothing to ride along with.";
+  writeWarning(job.status === "succeeded" ? `${lead} ${await finishedJobSeedAdvice(config, job, options)}` : `${lead} A canceled job is not seeded; deploy the package again to seed it.`);
+  return { ok: true, outcome: "nothing-to-resume", job };
+}
+async function settleConflict(config, existing, namedStatus, options) {
+  const [rereadError, reread] = await catchError(() => getDeployJob(config, existing.id, options.signal));
+  if (rereadError && options.signal?.aborted === true) {
+    return done({ ok: true, outcome: "detached", jobId: existing.id });
+  }
+  const status = reread?.status ?? knownJobStatus(namedStatus);
+  const flags = routingFlags(options);
+  const retry = `Check it with: uip vss deploy status ${existing.id}${flags}; then retry: uip vss deploy resume ${existing.id}${flags}`;
+  if (status === undefined) {
+    return done(failure("service-error", `Could not resume job ${existing.id}: the service refused the resume and its status could not be read back.`, retry, { retry: "RetryAfter10Seconds" }));
+  }
+  const settled = reread ?? { ...existing, status };
+  if (status === "running" || status === "queued") {
+    return {
+      kind: "live",
+      job: attachTo(settled, options),
+      attached: true
+    };
+  }
+  if (status === "succeeded" || status === "canceled") {
+    return done(await nothingToResume(config, settled, options));
+  }
+  return done(failure("service-error", `Could not resume job ${existing.id}: the service refused the resume, but the job is ${status}.`, retry, { retry: "RetryAfter10Seconds" }));
+}
+function done(result) {
+  return { kind: "done", result };
+}
+function attachTo(job, options) {
+  if (options.deploymentName) {
+    writeWarning("--deployment-name is ignored: the job is already running, so it is only " + "attached to, not restarted.");
+  }
+  writeProgress(`Attaching to the already-${job.status} job ${job.id}.`);
+  return job;
+}
+async function restartOrAttach(config, existing, options) {
+  if (existing.status === "running" || existing.status === "queued") {
+    return {
+      kind: "live",
+      job: attachTo(existing, options),
+      attached: true
+    };
+  }
+  const [error, resumed] = await catchError(withCapacityRetry(() => resumeDeployJob(config, existing.id, options.deploymentName, options.signal), "the resume", undefined, options.signal));
+  if (options.signal?.aborted) {
+    return done({ ok: true, outcome: "detached", jobId: existing.id });
+  }
+  if (error || !resumed) {
+    const finished = finishedJobConflict(error, "resume");
+    if (finished) {
+      return settleConflict(config, existing, finished.status, options);
+    }
+    return done(toDeployFailure(error, `Could not resume job ${existing.id}`, {
+      notFound: "job",
+      attempting: "resume",
+      jobId: existing.id,
+      routing: options
+    }));
+  }
+  if (options.deploymentName) {
+    writeProgress(`Resuming with deployment name "${options.deploymentName}".`);
+  }
+  writeProgress(`Job ${existing.id} resumed from the last checkpoint.`);
+  return { kind: "live", job: resumed, attached: false };
+}
+async function afterSuccess(config, job, options, deps, serviceUrl, attached) {
+  const [manifestError, manifest] = await catchError(readJobManifest(config, job, options.signal));
+  const workspace = {
+    config,
+    job,
+    deploymentName: job.deploymentName ?? (attached ? undefined : options.deploymentName),
+    options,
+    serviceUrl
+  };
+  if (manifestError || !manifest) {
+    const outcome = await prepareWorkspaceWithoutManifest(workspace);
+    writeWarning(`Could not read the package manifest (${manifestError?.message ?? "unknown error"}), ` + "so seeding is not offered." + (outcome.seedWorkspace === undefined ? " The seed workspace was not written either; the next step below says how to write it." : " The seed workspace is still written."));
+    return outcome;
+  }
+  return finalizeSucceededJob({ ...workspace, manifest, deps });
+}
+async function readJobManifest(config, job, signal) {
+  const named = namedJob(job);
+  if (!named)
+    throw new Error("the job carries no package name or version");
+  return getManifest(config, named.packageName, named.packageVersion, signal);
+}
+export {
+  runResume
+};
+
+//# debugId=D53A22B85A132A4564756E2164756E21