@uipath/packager-tool-case 1.202.0 → 1.203.0-preview.160

package/dist/THIRD-PARTY-NOTICES.md

@@ -5,4 +5,86 @@ compiled into its `dist/` output rather than installed alongside it.
 Their licences and copyright notices are reproduced here in full, as
 those licences require.
 
-No third-party code is bundled into this package.
+6 bundled dependencies:
+
+- @uipath/case-schema@0.1052.3 — UNLICENSED
+- lodash.isequal — MIT
+- lodash.keys — MIT
+- lodash.merge — MIT
+- lodash.xor — MIT
+- to-json-schema — MIT
+
+---
+
+## @uipath/case-schema@0.1052.3
+
+SPDX: UNLICENSED
+
+The upstream package ships no licence file here; `UNLICENSED` is the
+licence it is distributed under. The canonical text of that licence
+applies, with copyright held by the package's authors.
+
+---
+
+## lodash.isequal
+
+Inlined by a bundled dependency rather than resolved directly,
+so it does not appear in this package's source maps.
+
+SPDX: MIT
+
+The upstream package ships no licence file here; `MIT` is the
+licence it is distributed under. The canonical text of that licence
+applies, with copyright held by the package's authors.
+
+---
+
+## lodash.keys
+
+Inlined by a bundled dependency rather than resolved directly,
+so it does not appear in this package's source maps.
+
+SPDX: MIT
+
+The upstream package ships no licence file here; `MIT` is the
+licence it is distributed under. The canonical text of that licence
+applies, with copyright held by the package's authors.
+
+---
+
+## lodash.merge
+
+Inlined by a bundled dependency rather than resolved directly,
+so it does not appear in this package's source maps.
+
+SPDX: MIT
+
+The upstream package ships no licence file here; `MIT` is the
+licence it is distributed under. The canonical text of that licence
+applies, with copyright held by the package's authors.
+
+---
+
+## lodash.xor
+
+Inlined by a bundled dependency rather than resolved directly,
+so it does not appear in this package's source maps.
+
+SPDX: MIT
+
+The upstream package ships no licence file here; `MIT` is the
+licence it is distributed under. The canonical text of that licence
+applies, with copyright held by the package's authors.
+
+---
+
+## to-json-schema
+
+Inlined by a bundled dependency rather than resolved directly,
+so it does not appear in this package's source maps.
+
+SPDX: MIT
+
+The upstream package ships no licence file here; `MIT` is the
+licence it is distributed under. The canonical text of that licence
+applies, with copyright held by the package's authors.

package/dist/case-plan-file.d.ts

@@ -0,0 +1,89 @@
+import { type PackageDescriptorFileModel } from "@uipath/solutionpackager-tool-core";
+/**
+ * The names Studio Web gives a case plan on disk, newest first.
+ *
+ * Studio Web owns this file. It renames the plan to the newest name on every
+ * save and reads all four, so a project last saved on an earlier release still
+ * carries an older name and has to keep resolving.
+ *
+ * Match the whole name, not a `.case` suffix. A standalone canvas download can
+ * be any `<name>.case`, but inside a project Studio Web writes and reads these
+ * four exactly.
+ *
+ * @public
+ */
+export declare const CasePlanFileNames: readonly ["caseplan.case", "caseplan.json", "case.stage.json", "default.stage.json"];
+/**
+ * The compiled BPMN's name: the plan's own full name plus `.bpmn`.
+ *
+ * `entry-points.json` records that name and the runtime resolves it by exact
+ * match, so deriving it here is what stops a renamed plan from shipping
+ * against the sidecar of the name it used to have.
+ */
+export declare const casePlanSidecarName: (casePlanFileName: string) => string;
+/**
+ * The case plan among `entries`, or `undefined` when none is there.
+ *
+ * Precedence is the declaration order, so a project holding both a new and an
+ * old name resolves to the new one, the way Studio Web does.
+ */
+export declare const findCasePlanFileName: (entries: readonly string[]) => string | undefined;
+/**
+ * The name a declared `filePath` resolves to, or `""` when it does not.
+ *
+ * Any directory other than `content/` (or none) does not resolve at all:
+ * content/ is flat, so a path naming some other directory cannot be the file
+ * actually present there, even when its own basename happens to match one
+ * that is.
+ */
+export declare const resolveDeclaredFileName: (filePath: string) => string;
+/**
+ * A declared `filePath`, rewritten to the single form PIMS accepts:
+ * `/<name>#<fragment>`, regardless of which prefix form the project wrote.
+ *
+ * Debug uploads this value, not the raw `filePath` — the same string
+ * {@link resolveDeclaredFileName} validates. Without sharing the prefix rule,
+ * a path that passes validation (any accepted prefix form) could still reach
+ * PIMS in a form only one of those forms happens to produce correctly.
+ */
+export declare const normalizeEntryPointPath: (filePath: string) => string;
+/**
+ * The `.bpmn` names `entry-points.json` declares, or `null` when the document
+ * cannot be read as JSON, is not an object, its `entryPoints` is present but
+ * not a list, or an entry in that list has no usable `filePath`.
+ *
+ * `null` rather than an empty list: treating an unreadable document as
+ * "nothing declared" waves through the package whose entry point is exactly
+ * what the caller wanted to check. A `filePath` that is missing, not a
+ * string, or resolves to no name at all (empty, a bare `#fragment`, or a
+ * directory other than `content/`) gets the same treatment: silently
+ * dropping it, the way an entry naming a real but non-`.bpmn` file is
+ * dropped, would let `case debug` upload with an empty `entryPoint` instead
+ * of failing before the upload.
+ */
+export declare const entryPointBpmnNames: (entryPointsJson: string) => string[] | null;
+/**
+ * The declared BPMN that belongs to a plan other than `casePlanFileName`, or
+ * `undefined` when every declared name is either this plan's own sidecar or a
+ * BPMN no plan compiles to.
+ *
+ * Studio Web can leave a sidecar named after the newest plan name beside a plan
+ * it did not rename, and point the entry point at it. The file is on disk, so a
+ * presence check passes and the runtime resolves the stale BPMN. A name no plan
+ * compiles to is a project shipping its own, which is a supported shape.
+ */
+export declare const misnamedEntryPointBpmn: (declared: readonly string[], casePlanFileName: string) => string | undefined;
+/**
+ * `package-descriptor.json` for a case package, naming whichever plan file
+ * and `.bpmn` files the build actually produced.
+ *
+ * Studio Web renames the plan without touching the project's own
+ * `package-descriptor.json`, so a copy of that file made after a rename
+ * still names the sidecar the plan used to compile to. Regenerating it from
+ * the package's real content instead of copying the project's copy is what
+ * keeps the two in step. The plan itself is included alongside its sidecar
+ * because `case init` seeds a descriptor with both, and dropping the plan's
+ * own entry here would still change that shape even though nothing resolves
+ * entry points against it.
+ */
+export declare const buildCasePackageDescriptor: (contentFileNames: readonly string[]) => PackageDescriptorFileModel;

package/dist/case-tool.d.ts

@@ -3,8 +3,8 @@ import { type IFileSystem, type IToolLogger, ProjectTool, ToolResult } from "@ui
 /**
  * Case Management project tool implementation.
  *
- * The authored source is `caseplan.json`; the runtime reads the BPMN compiled
- * from it. `entry-points.json` points at `/content/caseplan.json.bpmn`, so the
+ * The authored source is the case plan; the runtime reads the BPMN compiled
+ * from it. `entry-points.json` points at that BPMN by name, so the
  * build compiles that file into content/ — a package without it deploys and
  * activates fine and then faults every job it starts (UV-15809). All files are
  * placed in the content/ folder (no separate source folder like flow_files/).
@@ -23,7 +23,8 @@ export declare class CaseTool extends ProjectTool {
      */
     private copyFiles;
     /**
-     * Compile `caseplan.json` into `content/caseplan.json.bpmn`.
+     * Compile the case plan into the BPMN the runtime resolves, named after
+     * the plan itself.
      *
      * Runs after copyFiles on purpose: a stale `caseplan.json.bpmn` left in the
      * project directory by an earlier `uip maestro case pack` is copied in
@@ -49,20 +50,31 @@ export declare class CaseTool extends ProjectTool {
      * the one that is missing.
      *
      * No `entry-points.json` means nothing declares an entry point, so there is
-     * nothing to resolve and nothing to fail on.
+     * nothing to resolve and nothing to fail on. A declared name that belongs to
+     * a plan other than the one the project carries fails too, even when the
+     * file is present: it is a stale sidecar from before a rename.
      */
     private checkEntryPointBpmnPresent;
     /**
-     * The `.bpmn` file names `entry-points.json` refers to. Entries look like
-     * `/content/caseplan.json.bpmn#<triggerId>`; `uip case debug` writes them
-     * without the `content/` prefix, so both forms are accepted.
+     * The `.bpmn` file names `entry-points.json` refers to, read from content/.
      *
      * No file at all means nothing is declared, so the caller has nothing to
-     * check. A file that is there but cannot be read as JSON returns `null`:
-     * treating that as "nothing declared" would wave through the very package
-     * this check exists to stop, since the entry point it names is unknown.
+     * check. An empty or unreadable one returns `null`, which the caller
+     * reports: treating it as "nothing declared" would wave through the very
+     * package this check exists to stop.
      */
     private readEntryPointBpmnFiles;
+    /**
+     * The name `entry-points.json`'s first entry resolves to, unfiltered by
+     * the `.bpmn` suffix `readEntryPointBpmnFiles` applies.
+     *
+     * `createOperateFile` derives operate.json's `main` the same way
+     * (`resolveEntryPointMain` in packager-core), so `checkEntryPointBpmnPresent`
+     * has to check the exact value that call will end up trusting, not just
+     * the declared list as a whole. Only called once `readEntryPointBpmnFiles`
+     * has proven the file exists and parses, so the read here cannot fail.
+     */
+    private firstEntryPointFileName;
     /**
      * Create operate.json file if it doesn't already exist
      */

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 import { CaseToolFactory } from "./case-tool-factory.js";
 export { type CaseBpmnCompiler, registerCaseBpmnCompiler, } from "./case-bpmn-compiler.js";
+export { buildCasePackageDescriptor, CasePlanFileNames, casePlanSidecarName, entryPointBpmnNames, findCasePlanFileName, misnamedEntryPointBpmn, normalizeEntryPointPath, resolveDeclaredFileName, } from "./case-plan-file.js";
 export { CaseToolFactory };

package/dist/index.js

@@ -9,7 +9,7 @@ import {
 // src/case-tool.ts
 import {
   ensureContentOperateFile,
-  NugetConstants,
+  NugetConstants as NugetConstants2,
   NugetPackager,
   Path,
   ProjectTool,
@@ -29,12 +29,70 @@ function getCaseBpmnCompiler() {
   return _global[COMPILER_KEY];
 }
 
+// src/case-plan-file.ts
+import {
+  NugetConstants
+} from "@uipath/solutionpackager-tool-core";
+var CasePlanFileNames = [
+  "caseplan.case",
+  "caseplan.json",
+  "case.stage.json",
+  "default.stage.json"
+];
+var casePlanSidecarName = (casePlanFileName) => `${casePlanFileName}.bpmn`;
+var findCasePlanFileName = (entries) => {
+  const present = new Set(entries);
+  return CasePlanFileNames.find((candidate) => present.has(candidate));
+};
+var stripDeclaredFilePathPrefix = (filePath) => {
+  const withoutLeadingSlash = filePath.startsWith("/") ? filePath.slice(1) : filePath;
+  return withoutLeadingSlash.startsWith("content/") ? withoutLeadingSlash.slice("content/".length) : withoutLeadingSlash;
+};
+var resolveDeclaredFileName = (filePath) => {
+  const stripped = stripDeclaredFilePathPrefix(filePath.split("#")[0]);
+  return stripped.includes("/") ? "" : stripped;
+};
+var normalizeEntryPointPath = (filePath) => `/${stripDeclaredFilePathPrefix(filePath)}`;
+var entryPointBpmnNames = (entryPointsJson) => {
+  try {
+    const parsed = JSON.parse(entryPointsJson);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("document is not an object");
+    }
+    if (parsed.entryPoints !== undefined && !Array.isArray(parsed.entryPoints)) {
+      throw new Error("entryPoints is not a list");
+    }
+    const resolvedNames = (parsed.entryPoints ?? []).map((entry) => typeof entry.filePath === "string" ? resolveDeclaredFileName(entry.filePath) : "");
+    if (resolvedNames.includes("")) {
+      throw new Error("an entry point has no usable filePath");
+    }
+    const names = resolvedNames.filter((name) => name.endsWith(".bpmn"));
+    return [...new Set(names)];
+  } catch {
+    return null;
+  }
+};
+var misnamedEntryPointBpmn = (declared, casePlanFileName) => {
+  const own = casePlanSidecarName(casePlanFileName);
+  const otherPlans = new Set(CasePlanFileNames.filter((name) => name !== casePlanFileName).map(casePlanSidecarName));
+  return declared.find((file) => file !== own && otherPlans.has(file));
+};
+var buildCasePackageDescriptor = (contentFileNames) => ({
+  $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
+  files: {
+    [NugetConstants.OperateFileName]: `${NugetConstants.ContentFolderName}/${NugetConstants.OperateFileName}`,
+    [NugetConstants.EntryPointsFileName]: `${NugetConstants.ContentFolderName}/${NugetConstants.EntryPointsFileName}`,
+    [NugetConstants.BindingsFileId]: `${NugetConstants.ContentFolderName}/${NugetConstants.BindingsV2FileName}`,
+    ...Object.fromEntries(contentFileNames.filter((name) => name.endsWith(".bpmn") || CasePlanFileNames.includes(name)).map((name) => [
+      name,
+      `${NugetConstants.ContentFolderName}/${name}`
+    ]))
+  }
+});
+
 // src/case-tool.ts
 var CaseConstants = {
-  EntryPointsFileName: "entry-points.json",
-  BindingsV2FileName: "bindings_v2.json",
-  CasePlanFileName: "caseplan.json",
-  CompiledBpmnFileName: "caseplan.json.bpmn"
+  EntryPointsFileName: "entry-points.json"
 };
 
 class CaseTool extends ProjectTool {
@@ -53,8 +111,8 @@ class CaseTool extends ProjectTool {
   }
   async buildAsync(options, _cancellationToken) {
     const tempFolder = await this._temporaryStorage.getTempFolderPath();
-    const localBuildFolder = Path.join(tempFolder, NugetConstants.OutputFolderName);
-    const contentFolder = Path.join(localBuildFolder, NugetConstants.ContentFolderName);
+    const localBuildFolder = Path.join(tempFolder, NugetConstants2.OutputFolderName);
+    const contentFolder = Path.join(localBuildFolder, NugetConstants2.ContentFolderName);
     try {
       this.logger.progress("Copying files...");
       await this.copyFiles(options.projectPath, contentFolder);
@@ -121,39 +179,55 @@ class CaseTool extends ProjectTool {
   }
   async compileCasePlan(projectPath, contentFolder) {
     const compile = getCaseBpmnCompiler();
-    const casePlanPath = Path.join(projectPath, CaseConstants.CasePlanFileName);
-    if (!compile || !await this.fileSystem.exists(casePlanPath)) {
-      return this.checkEntryPointBpmnPresent(contentFolder);
+    const casePlanFileName = findCasePlanFileName(await this.fileSystem.readdir(projectPath));
+    if (!compile || !casePlanFileName) {
+      return this.checkEntryPointBpmnPresent(contentFolder, casePlanFileName);
     }
+    const sidecarFileName = casePlanSidecarName(casePlanFileName);
+    const casePlanPath = Path.join(projectPath, casePlanFileName);
     const casePlan = await this.fileSystem.readFile(casePlanPath);
     if (!casePlan || casePlan.length === 0) {
-      return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.CasePlanFileName}' in ${projectPath} is empty, so there is nothing to compile into '${CaseConstants.CompiledBpmnFileName}'. Author the case plan, or re-scaffold the project with 'uip maestro case init'.`);
+      return ToolResult.error(ToolErrorCodes.InternalError, `'${casePlanFileName}' in ${projectPath} is empty, so there is nothing to compile into '${sidecarFileName}'. Author the case plan, or re-scaffold the project with 'uip maestro case init'.`);
     }
     try {
       const bpmnXml = await compile(new TextDecoder().decode(casePlan));
-      await this.fileSystem.writeFile(Path.join(contentFolder, CaseConstants.CompiledBpmnFileName), bpmnXml);
-      return await this.checkEntryPointBpmnPresent(contentFolder);
+      await this.fileSystem.writeFile(Path.join(contentFolder, sidecarFileName), bpmnXml);
+      return await this.checkEntryPointBpmnPresent(contentFolder, casePlanFileName);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       this.logger.error(message);
-      return ToolResult.error(ToolErrorCodes.InternalError, `Failed to compile '${CaseConstants.CasePlanFileName}' into '${CaseConstants.CompiledBpmnFileName}': ${message}. Run 'uip maestro case validate ${projectPath}' to find the problem in the case plan, then pack again.`);
+      return ToolResult.error(ToolErrorCodes.InternalError, `Failed to compile '${casePlanFileName}' into '${sidecarFileName}': ${message}. Run 'uip maestro case validate ${projectPath}' to find the problem in the case plan, then pack again.`);
     }
   }
-  async checkEntryPointBpmnPresent(contentFolder) {
+  async checkEntryPointBpmnPresent(contentFolder, casePlanFileName) {
     const referenced = await this.readEntryPointBpmnFiles(contentFolder);
     if (referenced === null) {
       return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.EntryPointsFileName}' could not be read as JSON, so pack cannot check that the BPMN it declares is in the package. Fix or re-scaffold '${CaseConstants.EntryPointsFileName}', then pack again.`);
     }
+    const own = casePlanFileName ? casePlanSidecarName(casePlanFileName) : undefined;
+    const fix = own ?? `Author a case plan (${CasePlanFileNames.join(", ")}) so pack can compile it (see 'uip maestro case init'), then pack again.`;
+    const firstEntry = await this.firstEntryPointFileName(contentFolder);
+    if (firstEntry && !referenced.includes(firstEntry)) {
+      const firstEntryFix = own ? `Point the first entry point at '${own}', then pack again.` : fix;
+      return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.EntryPointsFileName}' first entry point resolves to '${firstEntry}', which is not a declared .bpmn file this project ships, so operate.json's main would name a file pack cannot produce. ${firstEntryFix}`);
+    }
     if (referenced.length === 0) {
       return ToolResult.success();
     }
     const contentFiles = await this.fileSystem.readdir(contentFolder);
     const missing = referenced.filter((file) => !contentFiles.includes(file));
     if (missing.length === 0) {
+      if (casePlanFileName) {
+        const misnamed = misnamedEntryPointBpmn(referenced, casePlanFileName);
+        if (misnamed) {
+          return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.EntryPointsFileName}' points at 'content/${misnamed}', the sidecar of a case plan this project does not carry. '${casePlanFileName}' compiles to '${own}', so the entry point would resolve to a BPMN pack did not produce. Point it at '${own}', then pack again.`);
+        }
+      }
       return ToolResult.success();
     }
-    const fix = missing.includes(CaseConstants.CompiledBpmnFileName) ? `Author '${CaseConstants.CasePlanFileName}' so pack can compile it (see 'uip maestro case init'), then pack again.` : `Add the missing file to the project, or point '${CaseConstants.EntryPointsFileName}' at the BPMN the project does ship, then pack again.`;
-    return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.EntryPointsFileName}' points at ${missing.map((f) => `'content/${f}'`).join(", ")}, which the package does not contain, so it would deploy and activate and then fault every job. ${fix}`);
+    const missingFix = casePlanFileName ? `Add the missing file to the project, or point '${CaseConstants.EntryPointsFileName}' at the BPMN the project does ship, then pack again.` : fix;
+    const missingList = missing.map((f) => `'content/${f}'`).join(", ");
+    return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.EntryPointsFileName}' points at ${missingList}, which the package does not contain, so it would deploy and activate and then fault every job. ${missingFix}`);
   }
   async readEntryPointBpmnFiles(contentFolder) {
     const entryPointsPath = Path.join(contentFolder, CaseConstants.EntryPointsFileName);
@@ -164,13 +238,13 @@ class CaseTool extends ProjectTool {
     if (!raw || raw.length === 0) {
       return null;
     }
-    try {
-      const parsed = JSON.parse(new TextDecoder().decode(raw));
-      const names = (parsed.entryPoints ?? []).map((entry) => entry.filePath ?? "").map((filePath) => filePath.split("#")[0]).map((filePath) => filePath.split("/").pop() ?? "").filter((name) => name.endsWith(".bpmn"));
-      return [...new Set(names)];
-    } catch {
-      return null;
-    }
+    return entryPointBpmnNames(new TextDecoder().decode(raw));
+  }
+  async firstEntryPointFileName(contentFolder) {
+    const raw = await this.fileSystem.readFile(Path.join(contentFolder, CaseConstants.EntryPointsFileName));
+    const parsed = JSON.parse(raw ? new TextDecoder().decode(raw) : "{}");
+    const filePath = parsed.entryPoints?.[0]?.filePath ?? "";
+    return resolveDeclaredFileName(filePath);
   }
   async createOperateFile(options, contentFolder) {
     await ensureContentOperateFile(this.fileSystem, {
@@ -181,21 +255,9 @@ class CaseTool extends ProjectTool {
     });
   }
   async createPackageDescriptor(localBuildFolder, contentFolder) {
-    const descriptorFiles = {};
-    descriptorFiles[NugetConstants.OperateFileName] = Path.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName);
-    descriptorFiles[CaseConstants.EntryPointsFileName] = Path.join(NugetConstants.ContentFolderName, CaseConstants.EntryPointsFileName);
-    descriptorFiles[NugetConstants.BindingsFileId] = Path.join(NugetConstants.ContentFolderName, CaseConstants.BindingsV2FileName);
     const contentFiles = await this.fileSystem.readdir(contentFolder);
-    for (const file of contentFiles) {
-      if (file.endsWith(".bpmn")) {
-        descriptorFiles[file] = Path.join(NugetConstants.ContentFolderName, file);
-      }
-    }
-    const packageDescriptorPath = Path.join(localBuildFolder, NugetConstants.ContentFolderName, NugetConstants.PackageDescriptorFileName);
-    const packageDescriptorJson = JSON.stringify({
-      $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
-      files: descriptorFiles
-    }, null, 2);
+    const packageDescriptorPath = Path.join(localBuildFolder, NugetConstants2.ContentFolderName, NugetConstants2.PackageDescriptorFileName);
+    const packageDescriptorJson = JSON.stringify(buildCasePackageDescriptor(contentFiles), null, 2);
     await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
   }
 }
@@ -213,8 +275,16 @@ class CaseToolFactory {
 // src/index.ts
 toolsFactoryRepository.registerProjectToolFactory(new CaseToolFactory);
 export {
+  CasePlanFileNames,
   CaseToolFactory,
-  registerCaseBpmnCompiler
+  buildCasePackageDescriptor,
+  casePlanSidecarName,
+  entryPointBpmnNames,
+  findCasePlanFileName,
+  misnamedEntryPointBpmn,
+  normalizeEntryPointPath,
+  registerCaseBpmnCompiler,
+  resolveDeclaredFileName
 };
 
-//# debugId=0879235A557F09E364756E2164756E21
+//# debugId=478D1E7AE28D7DC664756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/packager-tool-case",
-    "version": "1.202.0",
+    "version": "1.203.0-preview.160",
     "description": "UiPath Case Management tool implementation",
     "type": "module",
     "exports": {
@@ -22,10 +22,10 @@
     "files": [
         "dist"
     ],
-    "author": "",
+    "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
     "peerDependencies": {
-        "@uipath/solutionpackager-tool-core": "1.202.0"
+        "@uipath/solutionpackager-tool-core": "1.203.0"
     },
-    "gitHead": "23b5a7038ead7264439af18f8b807c7cc99a29d5"
+    "gitHead": "3a42062ba731afca4595ba9aa8a80afc9667528d"
 }