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

package/dist/seed-templates-sqqqratr.js

@@ -0,0 +1,14 @@
+import {
+  downloadSeedTemplates
+} from "./tool-maw0g02p.js";
+import"./tool-4z1dy1rn.js";
+import"./tool-87e2ps7f.js";
+import"./tool-vf2mgth0.js";
+import"./tool-pz9qm3dv.js";
+import"./tool-hdxtgckw.js";
+import"./tool-1yh8g550.js";
+export {
+  downloadSeedTemplates
+};
+
+//# debugId=EE62DC99F6B090D264756E2164756E21

package/dist/service-errors-jzbq3z7p.js

@@ -0,0 +1,22 @@
+import {
+  finishedJobConflict,
+  knownJobStatus,
+  toDeployFailure
+} from "./tool-r2epw08s.js";
+import"./tool-4z1dy1rn.js";
+import"./tool-87e2ps7f.js";
+import"./tool-cag2z2d6.js";
+import"./tool-h4f967yd.js";
+import"./tool-rr9fensp.js";
+import"./tool-s04z9t80.js";
+import"./tool-vf2mgth0.js";
+import"./tool-pz9qm3dv.js";
+import"./tool-hdxtgckw.js";
+import"./tool-1yh8g550.js";
+export {
+  finishedJobConflict,
+  knownJobStatus,
+  toDeployFailure
+};
+
+//# debugId=D3C5F4A4D99C441E64756E2164756E21

package/dist/solution-auth-zq6gyxsv.js

@@ -0,0 +1,11 @@
+import {
+  getSolutionAuthContext
+} from "./tool-keqjsxdx.js";
+import"./tool-38ad77wd.js";
+import"./tool-hdxtgckw.js";
+import"./tool-1yh8g550.js";
+export {
+  getSolutionAuthContext
+};
+
+//# debugId=4D0CD43FE95C1EC164756E2164756E21

package/dist/solution-deployments-m44fyb88.js

@@ -0,0 +1,33 @@
+import {
+  DEPLOYMENT_PAGE_SIZE,
+  MAX_DEPLOYMENT_PAGES,
+  NAMED_DEPLOYMENT_PAGE_SIZE,
+  SolutionDeploymentsError,
+  isCompletedUninstall,
+  isInstalledDeployment,
+  listDeploymentsNamed,
+  listDeploymentsOfSolution,
+  listSolutionDeployments,
+  newestDeployment,
+  resolveInstalledFolder,
+  solutionNameFromManifest
+} from "./tool-tjhwq0ez.js";
+import"./tool-pz9qm3dv.js";
+import"./tool-hdxtgckw.js";
+import"./tool-1yh8g550.js";
+export {
+  DEPLOYMENT_PAGE_SIZE,
+  MAX_DEPLOYMENT_PAGES,
+  NAMED_DEPLOYMENT_PAGE_SIZE,
+  SolutionDeploymentsError,
+  isCompletedUninstall,
+  isInstalledDeployment,
+  listDeploymentsNamed,
+  listDeploymentsOfSolution,
+  listSolutionDeployments,
+  newestDeployment,
+  resolveInstalledFolder,
+  solutionNameFromManifest
+};
+
+//# debugId=A05C45CFE3EAA2DB64756E2164756E21

package/dist/templates-85yrztpk.js

@@ -0,0 +1,15 @@
+import {
+  refreshSeedTemplates
+} from "./tool-yx29vb63.js";
+import"./tool-67587985.js";
+import"./tool-s9qbxa2g.js";
+import"./tool-87e2ps7f.js";
+import"./tool-vf2mgth0.js";
+import"./tool-pz9qm3dv.js";
+import"./tool-hdxtgckw.js";
+import"./tool-1yh8g550.js";
+export {
+  refreshSeedTemplates
+};
+
+//# debugId=E7B03CFCD570558E64756E2164756E21

package/dist/tool-342sz3hm.js

@@ -0,0 +1,439 @@
+import {
+  findFolderPath,
+  readSeedFile,
+  readStrategy,
+  removeSeedContext
+} from "./tool-e4qgwf9h.js";
+import {
+  acquireSeedWorkspaceLock,
+  entityNameProblem,
+  insideSeedRoot,
+  isPreservedWorkspaceFile,
+  namesSeedRoot,
+  packageDir
+} from "./tool-s9qbxa2g.js";
+import {
+  writeProgress,
+  writeWarning
+} from "./tool-v15vxc4x.js";
+import {
+  routingFlags,
+  shellQuote
+} from "./tool-cag2z2d6.js";
+import {
+  failure,
+  invalidOption
+} from "./tool-h4f967yd.js";
+import {
+  RESULTS,
+  canPrompt,
+  catchError
+} from "./tool-pz9qm3dv.js";
+import {
+  getFileSystem
+} from "./tool-hdxtgckw.js";
+import {
+  __require
+} from "./tool-1yh8g550.js";
+
+// src/services/pause-kinds.ts
+function describePauseKind(kind) {
+  switch (kind) {
+    case "activation_setup":
+      return "activation setup";
+    case "connection_setup":
+      return "its connections authorized";
+    case "configuration_setup":
+      return "the portal's configuration wizard";
+    case "token_expired":
+      return "a fresh login";
+    default:
+      return "attention";
+  }
+}
+function pauseInstructions(kind, resume) {
+  return kind === "token_expired" ? `Run 'uip login' (the job's token expired), then run: ${resume}` : `Complete that step, then run: ${resume}`;
+}
+function pauseRetry(kind) {
+  return kind === "token_expired" ? "RetryWillNotFix" : "RetryLater";
+}
+function pauseErrorCode(kind) {
+  return kind === "token_expired" ? "authentication_required" : undefined;
+}
+
+// src/services/post-deploy/seed-commands.ts
+function namedJob(job) {
+  const { packageName, packageVersion } = job;
+  if (!packageName || !packageVersion)
+    return;
+  return { ...job, packageName, packageVersion };
+}
+var FOLDER_SCOPE_UNKNOWN_NOTE = ". Pass --folder-key <key of the folder the solution installed into> only if " + "the package's entities are folder-scoped.";
+var FOLDER_PLACEHOLDER = " --folder-key <key of the folder the solution installed into>";
+function seedCommandFor(job, folderKey, routing, unknownFolder) {
+  return seedCommand(job, folderKey, routing, undefined, unknownFolder);
+}
+function seedCommand(job, folderKey, routing, dir, unknownFolder) {
+  const where = dir !== undefined ? ` --dir ${shellQuote(dir)}` : "";
+  const folder = folderKey ? ` --folder-key ${shellQuote(folderKey)}` : unknownFolder ? FOLDER_PLACEHOLDER : "";
+  return `uip vss deploy seed${where} --package-name ${shellQuote(job.packageName)} ` + `--package-version ${shellQuote(job.packageVersion)}${folder}${routingFlags(routing)}`;
+}
+function seedYesFlag(options) {
+  return options.seed === true && options.yes === true ? " --yes" : "";
+}
+function rejectSeedWithoutWait(options) {
+  if (options.seed !== true || options.wait !== false)
+    return;
+  const routing = routingFlags(options);
+  return invalidOption("--seed cannot be combined with --no-wait: seeding runs after the job succeeds, " + "and --no-wait returns before that.", "Drop --no-wait to watch the job and seed when it succeeds, or drop --seed and, once " + `uip vss deploy status <job-id>${routing} shows it succeeded, run: ` + `uip vss deploy seed --package-name <name> --package-version <version>${routing}` + seedYesFlag(options));
+}
+function linkedOutHint(job, installedFolderKey, options, target, folderFlag = "") {
+  const command = seedCommand(job, installedFolderKey, options, target) + `${folderFlag} --refresh${seedYesFlag(options)}`;
+  if (target === undefined) {
+    return `Remove the link, then seed with: ${command}`;
+  }
+  return "Replace the link with a real folder, or seed that folder on purpose with: " + command;
+}
+
+// src/services/post-deploy/workspace.ts
+function deploymentNameOf(input) {
+  return input.job.deploymentName ?? input.deploymentName;
+}
+async function prepareSeedWorkspace(input, installedFolderKey, folderUnknown = false, folderAdvice = FOLDER_PLACEHOLDER) {
+  const { job, options } = input;
+  const showPlaceholder = folderUnknown && folderAdvice === FOLDER_PLACEHOLDER;
+  const folder = showPlaceholder ? FOLDER_PLACEHOLDER : "";
+  const commandKey = folderUnknown ? undefined : installedFolderKey;
+  const base = seedCommandFor(job, commandKey, options, showPlaceholder);
+  const retry = `${base} --refresh${seedYesFlag(options)}`;
+  const usable = await usableWorkspaceDir(input, commandKey, retry, folder);
+  if (usable.dir === undefined)
+    return usable;
+  const workspaceDir = usable.dir;
+  const fs = getFileSystem();
+  const [mkdirError] = typeof fs.mkdir === "function" ? await catchError(fs.mkdir(workspaceDir)) : [undefined];
+  if (mkdirError) {
+    writeWarning(`Could not create the seed workspace ${workspaceDir}: ${mkdirError.message}. Try again with: ${retry}`);
+    return refreshHint(retry);
+  }
+  const [checkError, checked] = await catchError(insideSeedRoot(workspaceDir));
+  if (checkError) {
+    writeWarning(`Could not check the seed workspace: ${checkError.message}. Try again with: ${retry}`);
+    return refreshHint(retry);
+  }
+  if (!checked.ok) {
+    writeWarning(`Could not create a safe seed workspace: ${checked.message} ${checked.instructions}`);
+    return refreshHint(retry);
+  }
+  const [lockError, release] = await catchError(acquireSeedWorkspaceLock(workspaceDir));
+  if (lockError || !release) {
+    writeWarning(`Could not lock the seed workspace while refreshing it: ${lockError?.message ?? "no lock"}. Try again with: ${retry}`);
+    return refreshHint(retry);
+  }
+  try {
+    return await writeTemplates(input, {
+      workspaceDir,
+      installedFolderKey,
+      retry,
+      folder
+    });
+  } finally {
+    await catchError(release());
+  }
+}
+async function writeTemplates(input, target) {
+  const { job, config, options } = input;
+  const { retry } = target;
+  const { downloadSeedTemplates } = await import("./seed-templates-sqqqratr.js");
+  const { refreshSeedTemplates } = await import("./templates-85yrztpk.js");
+  const [downloadError, download] = await catchError(downloadSeedTemplates(config, job.packageName, job.packageVersion, options.signal));
+  if (downloadError || !download) {
+    writeWarning(`Could not download the seed templates: ${downloadError?.message ?? "unknown error"}. Try again with: ${retry}`);
+    return refreshHint(retry);
+  }
+  const replacing = await holdsUserFiles(target.workspaceDir);
+  const [extractError, extracted] = await catchError(() => refreshSeedTemplates({
+    dir: target.workspaceDir,
+    zip: download.zip,
+    lockHeld: true
+  }));
+  if (extractError || !extracted) {
+    writeWarning(`Could not write the seed templates: ${extractError?.message ?? "unknown error"}. Try again with: ${retry}`);
+    return refreshHint(retry);
+  }
+  for (const warning of extracted.warnings)
+    writeWarning(warning);
+  const recorded = await recordDeployContext(input, target.installedFolderKey, extracted.dir, retry);
+  const next = recorded ? `uip vss deploy seed${routingFlags(options)}${target.folder}${seedYesFlag(options)}` : retry;
+  const written = `Seed templates: ${extracted.written.length} file(s) written to ${extracted.dir}` + (replacing ? " (previous files replaced)" : "");
+  writeProgress(recorded ? `${written} — fill them in, then run: ${next}` : `${written}. The seed context could not be written, so run ${next} FIRST, before you` + " fill them in — it replaces the files, and without it a later run refuses them" + " as an unknown version.");
+  return recorded ? { dir: extracted.dir } : {
+    dir: extracted.dir,
+    seedHint: `Seed Data Fabric data with: ${retry}`,
+    pushWith: retry,
+    refreshFirst: true
+  };
+}
+async function holdsUserFiles(dir) {
+  const [error, entries] = await catchError(getFileSystem().readdir(dir));
+  if (error || !entries)
+    return false;
+  return entries.some((name) => !isPreservedWorkspaceFile(name));
+}
+function refreshHint(retry) {
+  return { seedHint: `Seed Data Fabric data with: ${retry}` };
+}
+async function usableWorkspaceDir(input, installedFolderKey, retry, folderFlag) {
+  const [error, linked] = await catchError(() => linkedOutWorkspace(input.job.packageName));
+  if (error) {
+    writeWarning(`Could not write the seed templates: ${error.message}. Try again with: ${retry}`);
+    return refreshHint(retry);
+  }
+  if (linked) {
+    const seedHint = linkedOutHint(input.job, installedFolderKey, input.options, linked.target, folderFlag);
+    writeWarning(`Not writing the seed templates: ${linked.message} ${seedHint}`);
+    return { seedHint };
+  }
+  return { dir: packageDir(input.job.packageName) };
+}
+async function linkedOutWorkspace(packageName) {
+  const dir = packageDir(packageName);
+  const located = await insideSeedRoot(dir);
+  if (located.ok)
+    return;
+  const target = await getFileSystem().realpath(dir);
+  const offerable = target !== dir && !await namesSeedRoot(target);
+  return {
+    message: located.message,
+    ...offerable ? { target } : {}
+  };
+}
+async function recordDeployContext(input, installedFolderKey, workspaceDir, command) {
+  const { job, config } = input;
+  const { recordSeedContext } = await import("./seed-service-2d1f7zaz.js");
+  const [contextError] = await catchError(recordSeedContext({
+    packageName: job.packageName,
+    packageVersion: job.packageVersion,
+    serviceUrl: input.serviceUrl,
+    organizationId: config.organizationId,
+    organizationName: config.organizationName,
+    tenantId: config.tenantId,
+    tenantName: config.tenantName,
+    folderKey: installedFolderKey,
+    deploymentName: deploymentNameOf(input)
+  }));
+  if (!contextError)
+    return true;
+  const [removeError] = await catchError(removeSeedContext(workspaceDir));
+  const stale = removeError ? ` The previous .seed-context.json could not be removed either (${removeError.message}), so do not run 'uip vss deploy seed' without arguments.` : "";
+  writeWarning(`Could not write the seed context: ${contextError.message}.${stale} Seed with: ${command} — run it before filling the CSVs in, since it replaces them.`);
+  return false;
+}
+
+// src/services/post-deploy/installed-folder.ts
+async function resolveInstalledFolder(input) {
+  if (input.job.installedFolderKey) {
+    const key = input.job.installedFolderKey;
+    const [, path2] = await catchError(findFolderPath(input.config, key, input.options.signal));
+    writeProgress(`  Data Fabric entities live in folder ${path2 ?? key} (${key}).`);
+    return { key, path: path2 };
+  }
+  const {
+    listDeploymentsOfSolution,
+    resolveInstalledFolder: resolveFromDeployments,
+    solutionNameFromManifest
+  } = await import("./solution-deployments-m44fyb88.js");
+  const solutionName = solutionNameFromManifest(input.manifest);
+  if (!solutionName)
+    return;
+  const [listError, deployments] = await catchError(listDeploymentsOfSolution(input.config, solutionName, input.options.signal, deploymentNameOf(input)));
+  if (listError || !deployments) {
+    writeWarning(`Could not read the installed solution's folder: ${listError?.message ?? "unknown error"}. Seeding may need --folder-key.`);
+    return;
+  }
+  const resolved = resolveFromDeployments({
+    deployments,
+    deploymentName: deploymentNameOf(input),
+    solutionName,
+    packageVersion: input.job.packageVersion,
+    preferNewest: false
+  });
+  if (resolved.kind !== "resolved")
+    return;
+  const [, ownPath] = await catchError(findFolderPath(input.config, resolved.folderKey, input.options.signal));
+  const path = ownPath ?? undefined;
+  writeProgress(`  Data Fabric entities live in folder ${path ?? resolved.folderKey} (${resolved.folderKey}).`);
+  return { key: resolved.folderKey, path };
+}
+
+// src/services/post-deploy/offer.ts
+async function describeSeedOffer(workspaceDir, manifest, config, folderKey, folderPath) {
+  const fs = getFileSystem();
+  const seeding = manifest.dataFabric?.seeding ?? {};
+  const entities = [];
+  for (const [name, declared] of Object.entries(seeding)) {
+    const read = await readSeedFile(fs, workspaceDir, name);
+    if (read.kind === "invalid") {
+      writeWarning(`${name}.csv could not be read — ${read.why}. Fix it before seeding.`);
+    }
+    if (read.kind === "absent") {
+      writeWarning(`No seed file for "${name}" at ${read.path}. It will be skipped.`);
+    }
+    entities.push({
+      name,
+      rows: read.kind === "table" ? read.table.rows.length : 0,
+      strategy: readStrategy(declared.strategy).strategy
+    });
+  }
+  return {
+    workspaceDir,
+    organizationName: config.organizationName,
+    tenantName: config.tenantName,
+    scope: folderKey ? `solution folder ${folderPath ?? folderKey}` : "tenant-level entities",
+    entities
+  };
+}
+async function wantsSeeding(options, offer, deps, pushWith, refreshFirst) {
+  if (options.seed === true)
+    return true;
+  if (options.seed === false)
+    return false;
+  if (!canPrompt())
+    return false;
+  if (await deps.confirmSeed(offer))
+    return true;
+  writeProgress(refreshFirst ? `Skipped. Run ${pushWith} before editing the files under ${offer.workspaceDir} — it replaces them.` : `Skipped. Edit the files under ${offer.workspaceDir}, then push with: ${pushWith}`);
+  return false;
+}
+async function runOfferedSeed(input, folderKey, workspaceDir, hint, templatesAreCurrent = false) {
+  const { job, options, deps } = input;
+  const yes = options.seed === true ? options.yes : undefined;
+  const retry = seedCommandFor(job, folderKey, options) + (templatesAreCurrent ? " --refresh" : "") + (yes ? " --yes" : "");
+  const { runSeed } = await import("./seed-service-2d1f7zaz.js");
+  const [seedError, seeded] = await catchError(runSeed({
+    packageName: job.packageName,
+    packageVersion: job.packageVersion,
+    folderKey,
+    yes,
+    serviceUrl: options.serviceUrl,
+    loginValidity: options.loginValidity,
+    tenant: options.tenant,
+    signal: options.signal,
+    ...templatesAreCurrent ? { templatesAreCurrent: true } : {}
+  }, deps.seed));
+  if (seedError || !seeded) {
+    writeWarning(`Seeding did not complete: ${seedError instanceof Error ? seedError.message : String(seedError)}. Retry with: ${retry}`);
+    return { seedWorkspace: workspaceDir, seedHint: hint };
+  }
+  if (!seeded.ok) {
+    writeWarning(`Seeding did not complete — fix the reported issue, then retry with: ${retry}`);
+    if (seeded.instructions)
+      writeWarning(seeded.instructions);
+    return {
+      seedWorkspace: workspaceDir,
+      seedHint: hint,
+      ...seeded.summaries ? { seeded: seeded.summaries } : {}
+    };
+  }
+  return {
+    seedWorkspace: seeded.workspaceDir,
+    seeded: seeded.summaries,
+    ...templatesAreCurrent ? { seedHint: hint } : {}
+  };
+}
+
+// src/services/post-deploy.ts
+async function prepareWorkspaceWithoutManifest(input) {
+  const job = namedJob(input.job);
+  if (!job) {
+    return {
+      seedHint: "The job carries no package name or version, so no seed workspace was " + "prepared. If the package seeds Data Fabric data, seed it with: " + "uip vss deploy seed --package-name <name> --package-version <version>" + routingFlags(input.options) + seedYesFlag(input.options) + FOLDER_SCOPE_UNKNOWN_NOTE
+    };
+  }
+  const prepared = await prepareSeedWorkspace({ ...input, job }, job.installedFolderKey, true, FOLDER_SCOPE_UNKNOWN_NOTE);
+  const seedHint = (prepared.seedHint ?? `Seed Data Fabric data with: ${seedCommandFor(job, undefined, input.options, false)}` + seedYesFlag(input.options)) + FOLDER_SCOPE_UNKNOWN_NOTE;
+  return prepared.dir === undefined ? { seedHint } : { seedWorkspace: prepared.dir, seedHint };
+}
+async function finalizeSucceededJob(input) {
+  const { manifest, options } = input;
+  const seedingEntities = Object.keys(manifest.dataFabric?.seeding ?? {});
+  if (seedingEntities.length === 0)
+    return {};
+  const job = namedJob(input.job);
+  if (!job) {
+    const folder = manifest.dataFabric?.schemaFilename ? "" : FOLDER_PLACEHOLDER;
+    return {
+      seedHint: "This package seeds Data Fabric data, but the job the service answered with " + "carries no package name or version, so no seed workspace was prepared. Seed " + "it with: uip vss deploy seed --package-name <name> --package-version <version>" + `${folder}${routingFlags(options)}${seedYesFlag(options)}`
+    };
+  }
+  const unusable = seedingEntities.filter((name) => entityNameProblem(name));
+  if (unusable.length > 0)
+    return withholdForUnusableNames(unusable);
+  return prepareAndOffer({ ...input, job });
+}
+async function prepareAndOffer(input) {
+  const { job, manifest, options } = input;
+  const tenantLevel = Boolean(manifest.dataFabric?.schemaFilename);
+  const installed = tenantLevel ? undefined : await resolveInstalledFolder(input);
+  const folderUnknown = !tenantLevel && !installed;
+  const prepared = await prepareSeedWorkspace(input, installed?.key, folderUnknown);
+  const workspaceDir = prepared.dir;
+  const hint = prepared.seedHint ?? `Seed Data Fabric data with: ${seedCommandFor(job, installed?.key, options)}` + (folderUnknown ? FOLDER_PLACEHOLDER : "") + seedYesFlag(options);
+  if (workspaceDir === undefined)
+    return { seedHint: hint };
+  if (folderUnknown) {
+    writeWarning("Not offering to seed: the folder the solution installed into is not known. " + "Find it in Orchestrator (the Solution folder under the deploy target) and pass it as --folder-key.");
+    return { seedWorkspace: workspaceDir, seedHint: hint };
+  }
+  const folderKey = installed?.key;
+  const offer = await describeSeedOffer(workspaceDir, manifest, input.config, folderKey, installed?.path);
+  const [askError, wanted] = await catchError(wantsSeeding(options, offer, input.deps, prepared.pushWith ?? `uip vss deploy seed${routingFlags(options)}`, prepared.refreshFirst === true));
+  if (askError || !wanted) {
+    if (askError) {
+      writeProgress(`Not seeding. Push the data later with: ${seedCommandFor(job, folderKey, options)}`);
+    }
+    return { seedWorkspace: workspaceDir, seedHint: hint };
+  }
+  return runOfferedSeed(input, folderKey, workspaceDir, hint, prepared.pushWith !== undefined);
+}
+function withholdForUnusableNames(unusable) {
+  const names = unusable.map((name) => JSON.stringify(name)).join(", ");
+  writeWarning(`Not seeding: the package manifest names seeding entities that cannot be seed file names: ${names}. ` + "'uip vss deploy seed' refuses the package until they are fixed.");
+  return {
+    seedHint: "Fix the entity names under dataFabric.seeding in the package manifest and republish the package, " + "then deploy the new version to seed it."
+  };
+}
+
+// src/services/watch/stopped.ts
+function stoppedWatching(outcome, jobId, timeoutSeconds, routing) {
+  const flags = routingFlags(routing);
+  switch (outcome.kind) {
+    case "detached":
+      return {
+        ok: true,
+        outcome: "detached",
+        jobId,
+        ...outcome.job ? { status: outcome.job.status } : {}
+      };
+    case "timeout":
+      return failure("poll-timeout", `Stopped watching job ${jobId} after the ${timeoutSeconds}s timeout. ${jobStateAtTimeout(outcome.job)}`, `Check on it with: uip vss deploy status ${jobId}${flags}`, { result: RESULTS.TimeoutError });
+    default:
+      return failure("lost-contact", `Lost contact with job ${jobId}: ${outcome.error.message}`, `The job keeps running server-side. Re-attach with: uip vss deploy resume ${jobId}${flags}`);
+  }
+}
+function jobStateAtTimeout(job) {
+  if (job?.status === "action_required") {
+    return "The job is paused server-side, waiting for the step it needs.";
+  }
+  if (job?.status === "failed") {
+    return "The job failed and stays checkpointed server-side.";
+  }
+  if (!job) {
+    return "Where the job got to is not known: the last answer the watch was waiting for never arrived.";
+  }
+  return "The job is still running.";
+}
+
+export { describePauseKind, pauseInstructions, pauseRetry, pauseErrorCode, namedJob, FOLDER_SCOPE_UNKNOWN_NOTE, FOLDER_PLACEHOLDER, seedCommandFor, seedYesFlag, rejectSeedWithoutWait, linkedOutHint, linkedOutWorkspace, prepareWorkspaceWithoutManifest, finalizeSucceededJob, stoppedWatching };
+
+//# debugId=A19FD87D70E0449664756E2164756E21