@uipath/solution-tool 1.204.0 → 1.205.0-preview.258

package/dist/packager-tool-qk21gk5m.js

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

package/dist/{packager-tool-bqre28m1.js → packager-tool-qw47eyw7.js}

@@ -1,6 +1,6 @@
 import {
   resolveSessionIdentity
-} from "./packager-tool-gb35b4qs.js";
+} from "./packager-tool-43ahv5mn.js";
 
 // src/services/feed-session.ts
 function classifyFeedSession(session) {

package/dist/packager-tool-resolver-994z3jkj.js

@@ -0,0 +1,23 @@
+import {
+  UnpackableProjectTypeError,
+  ensurePackagerTools,
+  isUnpackableProjectTypeError
+} from "./packager-tool-b2nhscfk.js";
+import {
+  toolVerbForProjectType
+} from "./packager-tool-60af1hw2.js";
+import"./packager-tool-5ddtwzva.js";
+import"./packager-tool-pbmqk39a.js";
+import"./packager-tool-tx834spe.js";
+import"./packager-tool-6ybywxxn.js";
+import"./packager-tool-v1f5e8t9.js";
+import"./packager-tool-dfrk01gn.js";
+import"./packager-tool-1de529jm.js";
+export {
+  UnpackableProjectTypeError,
+  ensurePackagerTools,
+  isUnpackableProjectTypeError,
+  toolVerbForProjectType
+};
+
+//# debugId=0070262AA7F4F4B364756E2164756E21

package/dist/{packager-tool-gab9y5ct.js → packager-tool-t8gh825q.js}

@@ -3,10 +3,10 @@ import {
   assertNoContributionErrors,
   collectProjectContributions,
   contributionErrorMessages
-} from "./packager-tool-1rzssy0x.js";
+} from "./packager-tool-wy4fx250.js";
 import {
   ensurePackagerTools
-} from "./packager-tool-e2rtr49j.js";
+} from "./packager-tool-b2nhscfk.js";
 import {
   Tokens,
   createResourceBuilderServices,
@@ -17,14 +17,16 @@ import {
   models_BindingsResourceType,
   readUipxProjects,
   syncAndLog
-} from "./packager-tool-yrz4mwfn.js";
+} from "./packager-tool-6kz1pv9f.js";
 import {
-  catchError,
   logger
-} from "./packager-tool-kswwd3hp.js";
+} from "./packager-tool-tx834spe.js";
+import {
+  catchError
+} from "./packager-tool-6ybywxxn.js";
 import {
   getFileSystem
-} from "./packager-tool-zf3929se.js";
+} from "./packager-tool-v1f5e8t9.js";
 
 // src/services/emit-runtime-dependencies.ts
 import { createHash } from "node:crypto";
@@ -44,7 +46,7 @@ function solutionFolderKey() {
   solutionFolderKeyCache ??= csharpGuidFromString("solution_folder");
   return solutionFolderKeyCache;
 }
-async function emitRuntimeDependenciesForProcesses(solutionDir) {
+async function emitRuntimeDependenciesForProcesses(solutionDir, projectBindings) {
   const result = {
     processed: 0,
     warnings: []
@@ -85,7 +87,7 @@ async function emitRuntimeDependenciesForProcesses(solutionDir) {
         result.warnings.push(`Process resource "${proc.name}" has projectKey "${proc.projectKey}" but no matching project in .uipx; skipping`);
         continue;
       }
-      const bindings = await readBindings(project.path, serializer, fs, result.warnings);
+      const bindings = await readBindings(project.path, serializer, fs, result.warnings, projectBindings?.get(project.id));
       proc.runtimeDependencies = await buildRuntimeDeps(bindings, solution.resources ?? [], overwrites, builder, result.warnings);
       result.processed += 1;
       logger.info(`Emitted ${proc.runtimeDependencies.length} runtime dependencies for process "${proc.name}" (project "${project.name}")`);
@@ -110,7 +112,17 @@ async function emitRuntimeDependenciesForProcesses(solutionDir) {
     }
   }
 }
-async function readBindings(projectDir, serializer, fs, warnings) {
+async function readBindings(projectDir, serializer, fs, warnings, contributed) {
+  if (contributed !== undefined) {
+    if (contributed.length === 0)
+      return [];
+    const parsed2 = serializer.tryDeserialize(JSON.stringify({ version: "2.0", resources: contributed }));
+    if (!parsed2.success || !parsed2.metadata) {
+      warnings.push(`Failed to parse the bindings contributed by the project at ${projectDir}`);
+      return [];
+    }
+    return parsed2.metadata.resources ?? [];
+  }
   const bindingsPath = fs.path.join(projectDir, "bindings_v2.json");
   if (!await fs.exists(bindingsPath))
     return [];
@@ -216,6 +228,15 @@ function projectSubTypesFrom(contributions) {
   }
   return subTypes;
 }
+function projectBindingsFrom(contributions) {
+  const bindings = new Map;
+  for (const [projectKey, contribution] of contributions.byProject) {
+    if (contribution.bindings) {
+      bindings.set(projectKey, contribution.bindings);
+    }
+  }
+  return bindings;
+}
 async function prepareSolutionResources(solutionDir, fs, options) {
   const gate = options?.gate ?? true;
   const warnings = [];
@@ -226,7 +247,10 @@ async function prepareSolutionResources(solutionDir, fs, options) {
   } else {
     warnings.push(...contributionErrorMessages(contributions));
   }
-  await syncAndLog(solutionDir, projectSubTypesFrom(contributions));
+  await syncAndLog(solutionDir, projectSubTypesFrom(contributions), {
+    projectBindings: projectBindingsFrom(contributions),
+    failOnUnresolved: gate
+  });
   const applied = await applyProjectContributions(solutionDir, contributions, { failOnUnmatchedPatch: gate }, fs);
   warnings.push(...applied.warnings);
   for (const warning of applied.warnings)
@@ -234,13 +258,13 @@ async function prepareSolutionResources(solutionDir, fs, options) {
   if (applied.updated > 0) {
     logger.info(`Applied project resource contributions to ${applied.updated} resource(s)`);
   }
-  const rtd = await emitRuntimeDependenciesForProcesses(solutionDir);
+  const rtd = await emitRuntimeDependenciesForProcesses(solutionDir, projectBindingsFrom(contributions));
   warnings.push(...rtd.warnings);
   for (const warning of rtd.warnings)
     logger.warn(warning);
   return { warnings, updated: applied.updated };
 }
 
-export { projectSubTypesFrom, prepareSolutionResources };
+export { projectSubTypesFrom, projectBindingsFrom, prepareSolutionResources };
 
-//# debugId=16FA8B6372D1A69964756E2164756E21
+//# debugId=5FC361C697C3B19464756E2164756E21