@uipath/solution-tool 1.202.1 → 1.203.0-preview.180

package/dist/packager-tool-znakt6yw.js

@@ -0,0 +1,188 @@
+import {
+  toolVerbForProjectType
+} from "./packager-tool-k4mskzww.js";
+import {
+  computeEntryPointSpec,
+  createResourceBuilderServices,
+  hasAnyTemplateRow,
+  hasBareTemplateRow,
+  readUipxProjects
+} from "./packager-tool-bkwnetqn.js";
+import {
+  toolsFactoryRepository
+} from "./packager-tool-nzghfa48.js";
+import {
+  catchError,
+  getFileSystem,
+  logger
+} from "./packager-tool-0f0wt9vh.js";
+
+// src/services/project-contributions.ts
+var ENTRY_POINT_RESOURCE_KIND = "process";
+
+class ProjectContributionsError extends Error {
+  contributionErrors;
+  instructions;
+  errorCode = "invalid_argument";
+  contributionCode;
+  constructor(errors) {
+    super(errors.map((e) => e.message).join(`
+`));
+    this.name = "ProjectContributionsError";
+    this.contributionErrors = errors;
+    const instructions = errors.map((e) => e.instructions).filter((i) => typeof i === "string" && i.length > 0);
+    this.instructions = instructions.length > 0 ? [...new Set(instructions)].join(" ") : undefined;
+    const codes = errors.map((e) => e.code);
+    const everyCoded = codes.every((c) => typeof c === "string" && c.length > 0);
+    this.contributionCode = everyCoded && new Set(codes).size === 1 ? codes[0] : undefined;
+  }
+}
+async function collectProjectContributions(solutionDir, fs = getFileSystem()) {
+  const byProject = new Map;
+  const skipped = [];
+  const projects = await readUipxProjects(solutionDir);
+  for (const project of projects) {
+    if (!toolsFactoryRepository.canHandleProject(project.type))
+      continue;
+    const factory = toolsFactoryRepository.getProjectToolFactory(project.type);
+    if (typeof factory.describeResourcesAsync !== "function") {
+      const verb = toolVerbForProjectType(project.type);
+      const update = verb ? `update the tool that provides it ('uip tools install ${verb}')` : "update the tool that provides it";
+      if (!hasBareTemplateRow(project.type) && hasAnyTemplateRow(project.type)) {
+        byProject.set(project.id, {
+          errors: [
+            {
+              code: "contribution_unavailable",
+              message: `Project '${project.name}' (${project.type}) has no resource contribution: the installed tool for its type predates the contract, and ${project.type} artefact resources are generated only from that contribution.`,
+              instructions: `To generate them, ${update}, then re-run the command.`
+            }
+          ]
+        });
+        continue;
+      }
+      const notice = `Project '${project.name}' (${project.type}) was not checked for resource contributions; ${update}.`;
+      skipped.push(notice);
+      logger.warn(notice);
+      continue;
+    }
+    const [describeError, contribution] = await catchError(factory.describeResourcesAsync(project.path, fs));
+    if (describeError) {
+      byProject.set(project.id, {
+        errors: [
+          {
+            code: "contribution_failed",
+            message: `Project '${project.name}' (${project.type}) failed to describe its resource contribution: ${describeError.message}`,
+            instructions: `Fix the reported problem in ${project.path}, then re-run the command.`
+          }
+        ]
+      });
+      continue;
+    }
+    if (contribution)
+      byProject.set(project.id, contribution);
+  }
+  return { byProject, skipped };
+}
+function assertNoContributionErrors(contributions) {
+  const errors = [...contributions.byProject.values()].flatMap((c) => c.errors ?? []);
+  if (errors.length === 0)
+    return;
+  throw new ProjectContributionsError(errors);
+}
+function contributionErrorMessages(contributions) {
+  return [...contributions.byProject.values()].flatMap((c) => c.errors ?? []).map((e) => e.instructions ? `${e.message} ${e.instructions}` : e.message);
+}
+async function applyProjectContributions(solutionDir, contributions, options, fs = getFileSystem()) {
+  const result = {
+    updated: 0,
+    warnings: [...contributions.skipped]
+  };
+  const services = await createResourceBuilderServices();
+  const builder = await services.getSolutionBuilder(solutionDir);
+  try {
+    const solution = await builder.context.loadAsync();
+    const resources = solution?.resources ?? [];
+    const touched = new Set;
+    for (const [projectKey, contribution] of contributions.byProject) {
+      for (const patch of contribution.specPatch ?? []) {
+        const matches = resources.filter((r) => r.projectKey === projectKey && r.kind?.toLowerCase() === patch.kind.toLowerCase());
+        if (matches.length === 0) {
+          const message = `No '${patch.kind}' resource found for project '${projectKey}' — nothing to apply the contributed spec to.`;
+          if (options?.failOnUnmatchedPatch) {
+            throw new Error(message);
+          }
+          result.warnings.push(message);
+          continue;
+        }
+        for (const resource of matches) {
+          if (applySpecValues(resource, patch.values)) {
+            touched.add(resource);
+          }
+        }
+      }
+    }
+    for (const resource of resources) {
+      if (!resource.projectKey)
+        continue;
+      if (resource.kind?.toLowerCase() !== ENTRY_POINT_RESOURCE_KIND) {
+        continue;
+      }
+      const [computeError, computed] = await catchError(computeEntryPointSpec(fs, solutionDir, resource.projectKey));
+      if (computeError) {
+        result.warnings.push(`Failed to read entry points for project '${resource.projectKey}': ${computeError.message}`);
+        continue;
+      }
+      if (!computed)
+        continue;
+      if (applySpecValues(resource, computed))
+        touched.add(resource);
+    }
+    result.updated = touched.size;
+    if (touched.size > 0 && solution) {
+      await builder.context.saveAsync(solution);
+    }
+    return result;
+  } finally {
+    const dispose = builder.disposeAsync;
+    if (typeof dispose === "function") {
+      const [disposeError] = await catchError(dispose.call(builder));
+      if (disposeError) {
+        logger.warn(`Failed to dispose solution builder after applying project contributions: ${disposeError.message}`);
+      }
+    }
+  }
+}
+function applySpecValues(resource, values) {
+  const spec = { ...resource.spec ?? {} };
+  let changed = false;
+  for (const [key, value] of Object.entries(values)) {
+    const existingKey = Object.keys(spec).find((k) => k.toLowerCase() === key.toLowerCase()) ?? key;
+    if (value === null) {
+      if (existingKey in spec) {
+        delete spec[existingKey];
+        changed = true;
+      }
+      continue;
+    }
+    if (isSameSpecValue(spec[existingKey], value))
+      continue;
+    spec[existingKey] = value;
+    changed = true;
+  }
+  if (changed) {
+    resource.spec = spec;
+  }
+  return changed;
+}
+function isSameSpecValue(a, b) {
+  if (a === b)
+    return true;
+  if (typeof a !== "object" || typeof b !== "object" || !a || !b) {
+    return false;
+  }
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+export { ProjectContributionsError, collectProjectContributions, assertNoContributionErrors, contributionErrorMessages, applyProjectContributions };
+
+//# debugId=F82FA56EE24E69EE64756E2164756E21

package/dist/packager-tool.d.ts

@@ -4,7 +4,7 @@
  * factory for Connector, the one project type no CLI tool owns — there is no
  * `connector` verb. Every other project type is registered by the tool that
  * owns it, through that tool's own `packager-tool` entry point, loaded on
- * demand by `ensurePackagerTools` (AGENTS.md Hard Rule #18).
+ * demand by `ensurePackagerTools` (AGENTS.md Hard Rule #19).
  *
  * Explicit, not a module-load side effect: `ensurePackagerTools` calls this at
  * the start of every pack / restore / cleanup, which is the only code that

package/dist/packager-tool.js

@@ -1,6 +1,6 @@
 import {
   registerPackagerFactories
-} from "./packager-tool-p6mgvgdk.js";
+} from "./packager-tool-jz2wbfjz.js";
 import"./packager-tool-nzghfa48.js";
 import"./packager-tool-dfrk01gn.js";
 import"./packager-tool-1de529jm.js";

package/dist/prepare-solution-resources-wds3r8bq.js

@@ -0,0 +1,22 @@
+import {
+  prepareSolutionResources,
+  projectSubTypesFrom
+} from "./packager-tool-7znqtw3f.js";
+import"./packager-tool-znakt6yw.js";
+import"./packager-tool-k4mskzww.js";
+import"./packager-tool-jz2wbfjz.js";
+import"./packager-tool-bkwnetqn.js";
+import"./packager-tool-gdtpsdn7.js";
+import"./packager-tool-53w8skv5.js";
+import"./packager-tool-nzghfa48.js";
+import"./packager-tool-2syrt51a.js";
+import"./packager-tool-3jrq7smt.js";
+import"./packager-tool-0f0wt9vh.js";
+import"./packager-tool-dfrk01gn.js";
+import"./packager-tool-1de529jm.js";
+export {
+  prepareSolutionResources,
+  projectSubTypesFrom
+};
+
+//# debugId=9F446E87789120A364756E2164756E21

package/dist/project-contributions-cvttys34.js

@@ -0,0 +1,27 @@
+import {
+  ProjectContributionsError,
+  applyProjectContributions,
+  assertNoContributionErrors,
+  collectProjectContributions,
+  contributionErrorMessages
+} from "./packager-tool-znakt6yw.js";
+import"./packager-tool-k4mskzww.js";
+import"./packager-tool-jz2wbfjz.js";
+import"./packager-tool-bkwnetqn.js";
+import"./packager-tool-gdtpsdn7.js";
+import"./packager-tool-53w8skv5.js";
+import"./packager-tool-nzghfa48.js";
+import"./packager-tool-2syrt51a.js";
+import"./packager-tool-3jrq7smt.js";
+import"./packager-tool-0f0wt9vh.js";
+import"./packager-tool-dfrk01gn.js";
+import"./packager-tool-1de529jm.js";
+export {
+  ProjectContributionsError,
+  applyProjectContributions,
+  assertNoContributionErrors,
+  collectProjectContributions,
+  contributionErrorMessages
+};
+
+//# debugId=5BEB743E097B870464756E2164756E21

package/dist/publish.js

@@ -1,14 +1,15 @@
 import {
   publishSolutionAsync
-} from "./packager-tool-svcjmtbs.js";
-import"./packager-tool-arkenm6k.js";
-import"./packager-tool-d83m85g9.js";
-import"./packager-tool-7s77bznz.js";
-import"./packager-tool-rqvyf18m.js";
+} from "./packager-tool-6byq9bhj.js";
+import"./packager-tool-40yp3re0.js";
+import"./packager-tool-f9vfa06w.js";
+import"./packager-tool-2syrt51a.js";
+import"./packager-tool-3jrq7smt.js";
+import"./packager-tool-0f0wt9vh.js";
 import"./packager-tool-dfrk01gn.js";
 import"./packager-tool-1de529jm.js";
 export {
   publishSolutionAsync
 };
 
-//# debugId=AD7DDE48BF35E04564756E2164756E21
+//# debugId=C6A6B2A4D9E3236B64756E2164756E21

package/dist/resource.js

@@ -1,13 +1,16 @@
 import {
   resourceRefreshAsync
-} from "./packager-tool-txs8perg.js";
+} from "./packager-tool-bkwnetqn.js";
+import"./packager-tool-gdtpsdn7.js";
+import"./packager-tool-53w8skv5.js";
 import"./packager-tool-nzghfa48.js";
-import"./packager-tool-7s77bznz.js";
-import"./packager-tool-rqvyf18m.js";
+import"./packager-tool-2syrt51a.js";
+import"./packager-tool-3jrq7smt.js";
+import"./packager-tool-0f0wt9vh.js";
 import"./packager-tool-dfrk01gn.js";
 import"./packager-tool-1de529jm.js";
 export {
   resourceRefreshAsync
 };
 
-//# debugId=54ED39ED9D918B1A64756E2164756E21
+//# debugId=EF371AE5DDFD388A64756E2164756E21

package/dist/services/deployment-validation.d.ts

@@ -0,0 +1,33 @@
+import type { InitOverrideFunction } from "@uipath/solution-sdk";
+import { DeploymentsApi, type SolutionDeploymentAction } from "@uipath/solution-sdk";
+import type { SolutionAuthContext } from "@uipath/solution-sdk/auth";
+export declare const NO_SERVER_REASON = "the server reported no reason.";
+/**
+ * How long one validation lookup may take.
+ *
+ * This runs after the caller's wait has already ended, so it has no budget
+ * left to inherit, and the generated SDK hands the request to `fetch` without
+ * a deadline of its own. Unbounded, a stalled lookup outlives `--timeout` and
+ * the command sits there instead of returning the failure it already knows
+ * about.
+ */
+export declare const LOOKUP_TIMEOUT_MS = 15000;
+/**
+ * Ask the server why an install/upgrade failed. Deployment records carry a
+ * status and no error field, so the validation result is the only place an
+ * actionable cause lives (e.g. `SolutionFolderNotFound`).
+ *
+ * Best-effort: this runs on an already-failing path, so a second failure here
+ * must not replace the caller's message with a transport error.
+ */
+export declare function describeValidationFailureAsync(deploymentsApi: DeploymentsApi, deploymentKey: string, deploymentAction: SolutionDeploymentAction, scope: InitOverrideFunction | undefined, signal?: AbortSignal): Promise<string>;
+/**
+ * The same question for a deployment known only from its search record.
+ *
+ * A search row carries two keys and the API documents neither, so ask with
+ * `key` and fall back to `installDeploymentKey` when that answers nothing.
+ */
+export declare function describeDeploymentFailureAsync(auth: SolutionAuthContext, deployment: {
+    key: string;
+    installDeploymentKey?: string;
+}, deploymentAction: SolutionDeploymentAction, scope: InitOverrideFunction | undefined, signal?: AbortSignal): Promise<string>;

package/dist/services/governance-options.d.ts

@@ -1,3 +1,5 @@
+import type { IFileSystem } from "@uipath/filesystem";
+import { RulesConfigFileType } from "@uipath/solution-packager/node";
 import type { PackCommandOptions } from "../models";
 /**
  * What to do about a rejected governance option. Pairs with the message
@@ -23,4 +25,62 @@ export declare const GOVERNANCE_OPTION_INSTRUCTIONS: string;
  * `Message` from `Instructions`. Owning the wording here keeps the two paths
  * from drifting apart.
  */
-export declare function validateGovernanceOptions(options: Pick<PackCommandOptions, "governanceFilePath" | "automationOpsProfile">): string | null;
+export declare function validateGovernanceOptions(options: Pick<PackCommandOptions, "governanceFilePath" | "governanceProduct" | "automationOpsProfile">): string | null;
+/** What {@link detectGovernanceFileType} concluded about a policy file. */
+export type GovernanceFileDetection = {
+    kind: "detected";
+    fileType: RulesConfigFileType;
+} | {
+    kind: "unparseable";
+} | {
+    kind: "unwrapped-automation-ops";
+};
+/**
+ * Work out which rules-config source a local policy file belongs to.
+ *
+ * This exists because the compiler's `--policy-file-type` decides whether the
+ * policy is applied at all, and it does not fall back: handed an AutomationOps
+ * policy under `Studio`, the analyzer runs, reports nothing, and the pack
+ * succeeds — a policy escalating a rule to Error is silently discarded. The
+ * CLI has no flag for the type (`--governance-file-path` used to hardcode
+ * `Studio`), so a user's only realistic policy source — an AutomationOps
+ * export — never took effect.
+ *
+ * Anything that parses as JSON but carries no AutomationOps rule table is
+ * passed through as `Studio`. That is Studio's own rules-configuration format,
+ * whose schema lives inside the WorkflowCompiler, so the CLI cannot recognise
+ * it positively and must not reject it.
+ */
+export declare function detectGovernanceFileType(source: string): GovernanceFileDetection;
+/** Failure message for a policy file that could not be read. */
+export declare function governanceFileUnreadableMessage(path: string): string;
+/** Failure message for an AutomationOps policy stripped of its envelope. */
+export declare function governanceFileUnwrappedMessage(path: string): string;
+/** Failure message for a policy file that is not JSON. */
+export declare function governanceFileUnparseableMessage(path: string): string;
+/**
+ * Remedy for both read failures above. Deliberately does not say "drop the
+ * flag": the user asked for a policy, and packing without one would be the
+ * silent no-op this check exists to remove.
+ */
+export declare const GOVERNANCE_FILE_UNUSABLE_INSTRUCTIONS: string;
+/** Outcome of resolving `--governance-file-path` to a rules-config source. */
+export type GovernanceFileTypeResult = {
+    ok: true;
+    fileType: RulesConfigFileType;
+} | {
+    ok: false;
+    message: string;
+    instructions: string;
+};
+/**
+ * Read the policy file named by `--governance-file-path` and decide which
+ * rules-config source it belongs to.
+ *
+ * Reading it here, rather than leaving it to the packager's options validator,
+ * is what makes the choice possible at all: the type has to travel with the
+ * path, and the only way to tell the two formats apart is to look inside. A
+ * file that cannot be read or is not JSON fails the pack instead of falling
+ * back to a source that would discard it.
+ */
+export declare function resolveGovernanceFileTypeAsync(fs: IFileSystem, governanceFilePath: string): Promise<GovernanceFileTypeResult>;

package/dist/services/pack-command-service.d.ts

@@ -1,4 +1,4 @@
-import { type CommandContext } from "@uipath/common";
+import { type CliErrorCode, type CommandContext, RESULTS, type RetryHint } from "@uipath/common";
 import { ToolResult } from "@uipath/solutionpackager-tool-core";
 import type { PackCommandOptions } from "../models";
 /**
@@ -23,7 +23,8 @@ export declare class PackCommandService {
     execute(solutionPath: string, options: PackCommandOptions, context: CommandContext): Promise<void>;
     /**
      * The entry guards `executeAsync` runs before it touches a packager:
-     * a missing output path, bad governance options, and a solution path that
+     * a missing output path, bad governance options, a governance policy file
+     * whose rules-config source cannot be derived, and a solution path that
      * is absent or unreadable. Split out so `executeAsync` stays inside the
      * cognitive-complexity budget; each one still returns the `ToolResult`
      * that caller expects rather than throwing.
@@ -74,3 +75,33 @@ export declare class PackCommandService {
     private resolvePackageName;
     private createPackOptions;
 }
+/**
+ * The failure envelope for a pack the packager refused.
+ *
+ * Most failures keep the shape they have always had — `Error code: <tool code>
+ * : <message>` with the packager's own text as the next step — because the
+ * cause is whatever the compiler reported and there is nothing better to say.
+ * A member package id we know is unpublishable is different: the cause is a
+ * name on disk (a member folder, the `.uipx`), so it gets `invalid_argument`, a
+ * message without the tool-code prefix, and instructions naming what to
+ * rename. Agents branch on `ErrorCode`, and `unknown_error` there tells them
+ * this can never be fixed by the caller, which is the opposite of true.
+ *
+ * Instructions the packager carried up beat the generic next step, which for a
+ * non-dry-run pack is the message itself.
+ */
+export declare function packFailureEnvelope(result: {
+    errorCode: string;
+    message?: string;
+    instructions?: string;
+    details?: ToolResult["details"];
+}, dryRun: boolean): {
+    Result: typeof RESULTS.Failure;
+    Message: string;
+    Instructions: string;
+    ErrorCode?: CliErrorCode;
+    Retry?: RetryHint;
+    Data?: {
+        Projects: unknown[];
+    };
+};

package/dist/services/packager-tool-resolver.d.ts

@@ -1,3 +1,4 @@
+import { type CliErrorCode } from "@uipath/common";
 import type { IFileSystem } from "@uipath/filesystem";
 /**
  * A `.uipx` names a project type nothing can pack, and no tool provides one.
@@ -12,10 +13,12 @@ import type { IFileSystem } from "@uipath/filesystem";
 export declare class UnpackableProjectTypeError extends Error {
     readonly __unpackableType = true;
     readonly instructions: string;
+    readonly errorCode: CliErrorCode;
     constructor(projectType: string, projectPath: string);
 }
 /** True when `error` is an {@link UnpackableProjectTypeError}, duck-typed. */
 export declare function isUnpackableProjectTypeError(error: unknown): boolean;
+export { toolVerbForProjectType } from "./project-type-tools";
 /**
  * Puts every factory this pack needs in `toolsFactoryRepository`: registers
  * the ones solution-tool owns, then reads project types from the .uipx and

package/dist/services/prepare-solution-resources.d.ts

@@ -0,0 +1,40 @@
+import type { IFileSystem } from "@uipath/filesystem";
+import { type ProjectContributions } from "./project-contributions";
+export interface PrepareResult {
+    /** Contributed problems (when not gating), skips, and unmatched patches. */
+    warnings: string[];
+    /** Artefact resources whose spec was rewritten. */
+    updated: number;
+}
+/**
+ * The projects that told us which template variant their artefact resources
+ * come from, keyed by `.uipx` project `Id`. Opaque strings: the value is
+ * produced by the tool that owns the project type and consumed by the SDK's
+ * reconciler, and nothing in between reads it (AGENTS.md Hard Rule #19).
+ */
+export declare function projectSubTypesFrom(contributions: ProjectContributions): ReadonlyMap<string, string>;
+/**
+ * Bring a solution directory's resource JSONs in line with its projects'
+ * authored files. Every path that reads those resources for real — `pack`,
+ * `upload`, `resources refresh` — runs this, so a coded app gets the same
+ * treatment whichever one the user reaches for.
+ *
+ * The order is load-bearing:
+ *
+ * 1. `ensurePackagerTools` — the collect dispatches to registered factories.
+ * 2. collect — reads project files only, which the sync never touches, so
+ *    collecting before and applying after cannot see two different states.
+ * 3. gate (pack, upload) — a project reporting a problem with its own files
+ *    must fail before any write, not leave half-synced resources behind.
+ * 4. sync — carries the contributed subTypes, which is what lets reconcile
+ *    generate (or repair) artefact resources for a type whose template row is
+ *    keyed `<type>_<subType>`.
+ * 5. apply — after the sync, because the sync can create the app resource a
+ *    patch targets. An unmatched patch here is a contributor bug, not a race,
+ *    which is why gating callers also fail on one.
+ * 6. runtime dependencies — mirrors Orchestrator BE's
+ *    `ProcessesExportHandlerBase.GetRuntimeDependenciesAsync`.
+ */
+export declare function prepareSolutionResources(solutionDir: string, fs: IFileSystem, options?: {
+    gate?: boolean;
+}): Promise<PrepareResult>;

package/dist/services/project-contributions.d.ts

@@ -0,0 +1,58 @@
+import { type CliErrorCode } from "@uipath/common";
+import { type IFileSystem } from "@uipath/filesystem";
+import { type ProjectContributionError, type ProjectResourceContribution } from "@uipath/solutionpackager-tool-core";
+export interface ProjectContributions {
+    /** Per project key (the `.uipx` `Id`), what that project's factory returned. */
+    byProject: Map<string, ProjectResourceContribution>;
+    /** Supported types whose registered factory has no `describeResourcesAsync`. */
+    skipped: string[];
+}
+export interface ApplyContributionsResult {
+    /** Number of artefact resources whose spec was rewritten. */
+    updated: number;
+    /** Patches that matched no resource, plus the collect-time skip notices. */
+    warnings: string[];
+}
+/**
+ * Every contributed error from one collect, in one throw. Carries
+ * `instructions` so `carriedInstructions` can lift them into the failure
+ * envelope instead of losing the actionable half.
+ */
+export declare class ProjectContributionsError extends Error {
+    readonly contributionErrors: readonly ProjectContributionError[];
+    readonly instructions?: string;
+    readonly errorCode: CliErrorCode;
+    /** The contributed `code`, when every error in the batch reports the same one. */
+    readonly contributionCode?: string;
+    constructor(errors: readonly ProjectContributionError[]);
+}
+/**
+ * Walk the `.uipx` and ask each project's registered tool factory what it
+ * contributes. One walk, one dispatch round — pack uses the same result for
+ * its gate and its write.
+ *
+ * Reads project files only, which `syncAndLog` never touches, so collecting
+ * before the sync and applying after it cannot see two different states.
+ */
+export declare function collectProjectContributions(solutionDir: string, fs?: IFileSystem): Promise<ProjectContributions>;
+/** Throws once with every collected error. Pack's gate. */
+export declare function assertNoContributionErrors(contributions: ProjectContributions): void;
+/**
+ * Contributed errors as flat strings. Refresh folds these into its
+ * `Warnings[]` — it is a sync command, not a gate, but it must not swallow
+ * them either. Pack remains the gate.
+ */
+export declare function contributionErrorMessages(contributions: ProjectContributions): string[];
+/**
+ * Merge every `specPatch` into the on-disk resources, and write the
+ * entry-point keys while we are here so they persist into the packed solution
+ * instead of existing only at GET.
+ *
+ * Writes go through the resource builder, so a save re-runs
+ * `ArtefactPairBindingProvider` — deliberate: it is what keeps the app+package
+ * linkage intact when this rewrites an app resource. Nothing is saved when
+ * nothing changed, which is what keeps a re-run byte-stable.
+ */
+export declare function applyProjectContributions(solutionDir: string, contributions: ProjectContributions, options?: {
+    failOnUnmatchedPatch?: boolean;
+}, fs?: IFileSystem): Promise<ApplyContributionsResult>;

package/dist/services/project-type-tools.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The CLI verb that owns a project type, or `undefined` for a type nothing
+ * maps. Used to name the tool to install or update in an error or warning.
+ */
+export declare function toolVerbForProjectType(projectType: string): string | undefined;
+export declare function toolOwnedProjectTypes(): string[];