@uipath/case-tool 1.205.0-preview.281 → 1.206.0-preview.282

package/dist/packager-tool-4avchhz8.js

@@ -0,0 +1,539 @@
+import {
+  Path,
+  TemporaryStorageService,
+  NugetConstants,
+  ToolResult,
+  parseJsonObject,
+  readJsonObjectFile,
+  isDefaultFlag,
+  applyDefaultEntryPoint,
+  ensureContentOperateFile,
+  NugetPackager,
+  ProjectTool,
+  toolsFactoryRepository
+} from "./packager-tool-snesn0bt.js";
+import {
+  roleDescriptionOf,
+  caseStageLabels,
+  publishedRoleActions,
+  roleDeploys,
+  roleResourceKey,
+  readCaseRoles
+} from "./packager-tool-1wgav5ma.js";
+
+// ../packager/packager-tool-case/src/case-plan-file.ts
+var CasePlanFileNames2 = [
+  "caseplan.case",
+  "caseplan.json",
+  "case.stage.json",
+  "default.stage.json"
+];
+var casePlanSidecarName2 = (casePlanFileName) => `${casePlanFileName}.bpmn`;
+var findCasePlanFileName2 = (entries) => {
+  const present = new Set(entries);
+  return CasePlanFileNames2.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 resolveDeclaredFileName2 = (filePath) => {
+  const stripped = stripDeclaredFilePathPrefix(filePath.split("#")[0]);
+  return stripped.includes("/") ? "" : stripped;
+};
+var normalizeEntryPointPath2 = (filePath) => `/${stripDeclaredFilePathPrefix(filePath)}`;
+var entryPointBpmnNames2 = (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" ? resolveDeclaredFileName2(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 misnamedEntryPointBpmn2 = (declared, casePlanFileName) => {
+  const own = casePlanSidecarName2(casePlanFileName);
+  const otherPlans = new Set(CasePlanFileNames2.filter((name) => name !== casePlanFileName).map(casePlanSidecarName2));
+  return declared.find((file) => file !== own && otherPlans.has(file));
+};
+var stagedMainEntryPoint2 = (operateJson, entryPointsJson) => {
+  const main = parseJsonObject(operateJson)?.main;
+  if (typeof main === "string" && main !== "") {
+    return { filePath: main, source: "operate.json" };
+  }
+  const entryPoints = parseJsonObject(entryPointsJson)?.entryPoints;
+  const first = Array.isArray(entryPoints) ? entryPoints[0]?.filePath : undefined;
+  return {
+    filePath: typeof first === "string" ? first : "",
+    source: "entry-points.json"
+  };
+};
+var stagedMainProblem2 = (staged, resolved, own) => staged.source === "operate.json" ? {
+  problem: `operate.json's main names '${staged.filePath}', which resolves to '${resolved}'`,
+  fix: own ? `Mark the entry for '${own}' as default, or point operate.json's main at it` : undefined
+} : {
+  problem: `entry-points.json's first entry point resolves to '${resolved}'`,
+  fix: own ? `Mark the entry for '${own}' as default, or make it the first entry` : undefined
+};
+var buildCasePackageDescriptor2 = (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") || CasePlanFileNames2.includes(name)).map((name) => [
+      name,
+      `${NugetConstants.ContentFolderName}/${name}`
+    ]))
+  }
+});
+
+// ../packager/packager-tool-case/src/case-role-bindings.ts
+var ROLE_RESOURCE = "role";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var roleBindingName = (entry) => {
+  if (!isRecord(entry))
+    return;
+  if (String(entry.resource).toLowerCase() !== ROLE_RESOURCE) {
+    return;
+  }
+  const name = isRecord(entry.value) ? entry.value.name : undefined;
+  const defaultValue = isRecord(name) ? name.defaultValue : undefined;
+  return typeof defaultValue === "string" ? defaultValue : undefined;
+};
+var reconcileRoleBindings = (resources, roles) => {
+  const roleNames = new Set(roles.map((role) => role.name));
+  let changed = false;
+  const reconciled = resources.map((entry) => {
+    const bound = roleBindingName(entry);
+    if (bound === undefined || roleNames.has(bound))
+      return entry;
+    const record = entry;
+    const displayName = isRecord(record.metadata) ? record.metadata.displayName : undefined;
+    if (typeof displayName !== "string" || !roleNames.has(displayName)) {
+      return entry;
+    }
+    const value = record.value;
+    const name = value.name;
+    changed = true;
+    return {
+      ...record,
+      value: { ...value, name: { ...name, defaultValue: displayName } }
+    };
+  });
+  return { resources: reconciled, changed };
+};
+
+// ../packager/packager-tool-case/src/case-role-contribution.ts
+var BINDINGS_FILE_NAME = "bindings_v2.json";
+var ROLE_RESOURCE_KIND = "role";
+var CASE_ROLE_RESOURCE_TYPE = "case-role";
+async function describeCaseRoles(projectDir, fs) {
+  const entries = await fs.readdir(projectDir);
+  const planName = findCasePlanFileName2(entries);
+  if (planName === undefined)
+    return {};
+  const plan = await readJson(fs, fs.path.join(projectDir, planName));
+  if (plan === undefined)
+    return {};
+  const stages = caseStageLabels(isRecord2(plan) ? plan.nodes : undefined);
+  const roles = readCaseRoles(plan).filter((role) => roleDeploys(role, stages));
+  if (roles.length === 0)
+    return {};
+  const collisions = nameCollisions(roles);
+  if (collisions.length > 0) {
+    return {
+      errors: [
+        {
+          code: "case_role_name_collision",
+          message: `${planName} declares case roles whose names differ only by case (${collisions.join("; ")}). The solution stores one role resource per name regardless of case, so they would deploy as one.`,
+          instructions: `Rename one role of each pair in the Case Designer, run 'uip maestro case bindings sync ${planName}' in ${projectDir}, then pack again.`
+        }
+      ]
+    };
+  }
+  const sidecar = await readBindingResources(fs, projectDir);
+  const reconciled = reconcileRoleBindings(sidecar, roles);
+  const bound = roleBindingNames(reconciled.resources);
+  const unbound = roles.filter((role) => !bound.has(role.name));
+  if (unbound.length > 0) {
+    const names = unbound.map((role) => `"${role.name}"`).join(", ");
+    return {
+      errors: [
+        {
+          code: "case_role_unbound",
+          message: `${planName} declares case role(s) ${names} with no matching Role entry in ${BINDINGS_FILE_NAME}, so the solution would deploy without them.`,
+          instructions: `Run 'uip maestro case bindings sync ${planName}' in ${projectDir} to write the Role entries, then pack again.`
+        }
+      ]
+    };
+  }
+  return {
+    specPatch: roles.map(rolePatch),
+    ...reconciled.changed && {
+      bindings: reconciled.resources
+    }
+  };
+}
+var nameCollisions = (roles) => {
+  const byKey = new Map;
+  for (const role of roles) {
+    const key = roleResourceKey(role.name);
+    byKey.set(key, [...byKey.get(key) ?? [], role.name]);
+  }
+  return [...byKey.values()].filter((names) => names.length > 1).map((names) => names.map((name) => `"${name}"`).join(" and "));
+};
+var rolePatch = (role) => ({
+  kind: ROLE_RESOURCE_KIND,
+  type: CASE_ROLE_RESOURCE_TYPE,
+  name: role.name,
+  values: {
+    description: roleDescriptionOf(role),
+    actions: publishedRoleActions(role)
+  }
+});
+var roleBindingNames = (resources) => {
+  const names = new Set;
+  for (const entry of resources) {
+    const name = roleBindingName(entry);
+    if (name !== undefined)
+      names.add(name);
+  }
+  return names;
+};
+async function readBindingResources(fs, projectDir) {
+  const file = await readJson(fs, fs.path.join(projectDir, BINDINGS_FILE_NAME));
+  return isRecord2(file) && Array.isArray(file.resources) ? file.resources : [];
+}
+async function readJson(fs, path) {
+  try {
+    const raw = await fs.readFile(path, "utf-8");
+    if (raw === null || raw === undefined || raw === "")
+      return;
+    return JSON.parse(raw);
+  } catch {
+    return;
+  }
+}
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+
+// ../packager/packager-tool-case/src/case-bpmn-compiler.ts
+var COMPILER_KEY = Symbol.for("@uipath/packager-tool-case/caseBpmnCompiler");
+var _global = globalThis;
+function registerCaseBpmnCompiler(caseBpmnCompiler) {
+  _global[COMPILER_KEY] = caseBpmnCompiler;
+}
+function getCaseBpmnCompiler() {
+  return _global[COMPILER_KEY];
+}
+
+// ../packager/packager-tool-case/src/case-plan-triggers.ts
+var nonEmpty = (value) => typeof value === "string" && value !== "" ? value : undefined;
+function readCasePlanTriggers2(plan) {
+  const nodes = plan?.nodes;
+  if (!Array.isArray(nodes))
+    return [];
+  const triggers = [];
+  for (const node of nodes) {
+    if (typeof node !== "object" || node === null)
+      continue;
+    const isCurrent = node.type === "uipath.case.trigger";
+    if (!isCurrent && node.type !== "case-management:Trigger")
+      continue;
+    if (typeof node.id !== "string")
+      continue;
+    const inputs = node.data?.inputs;
+    const uipath = isCurrent ? undefined : node.data?.uipath;
+    const label = nonEmpty(isCurrent ? node.data?.display?.label : node.data?.label);
+    const entryPointId = nonEmpty(uipath?.entryPointId) ?? nonEmpty(inputs?.entryPointId);
+    const isDefault = uipath?.isDefault ?? inputs?.isDefault;
+    triggers.push({
+      id: node.id,
+      ...label !== undefined && { label },
+      ...entryPointId !== undefined && { entryPointId },
+      isDefault: isDefaultFlag(isDefault)
+    });
+  }
+  return triggers;
+}
+function withCasePlanDefaults2(entryPoints, plan, casePlanFileName) {
+  const flagged = new Set(readCasePlanTriggers2(plan).filter((trigger) => trigger.isDefault).map((trigger) => trigger.id));
+  if (flagged.size === 0)
+    return [...entryPoints];
+  const sidecar = casePlanSidecarName2(casePlanFileName);
+  const listed = new Set(entryPoints.flatMap((entry) => typeof entry === "object" && entry !== null && typeof entry.filePath === "string" && resolveDeclaredFileName2(entry.filePath) === sidecar ? [entry.filePath.split("#")[1] ?? ""] : []));
+  const unlisted = [...flagged].filter((id) => !listed.has(id));
+  if (unlisted.length > 0) {
+    throw new CasePlanDefaultNotListedError(unlisted);
+  }
+  return entryPoints.map((entry) => {
+    if (typeof entry !== "object" || entry === null)
+      return entry;
+    const { isDefault: _isDefault, ...rest } = entry;
+    const filePath = typeof entry.filePath === "string" ? entry.filePath : "";
+    const isDefault = resolveDeclaredFileName2(filePath) === sidecar && flagged.has(filePath.split("#")[1] ?? "");
+    return isDefault ? { ...rest, isDefault: true } : rest;
+  });
+}
+
+class CasePlanDefaultNotListedError extends Error {
+  triggerIds;
+  constructor(triggerIds) {
+    const names = triggerIds.map((id) => `'${id}'`).join(", ");
+    super(`The case plan flags ${triggerIds.length === 1 ? "trigger" : "triggers"} ${names} as the default, but entry-points.json has no entry for ${triggerIds.length === 1 ? "it" : "them"}, so the package could not start from ${triggerIds.length === 1 ? "it" : "them"}. Run 'uip maestro case init --force' to add the entry, then try again.`);
+    this.triggerIds = triggerIds;
+    this.name = "CasePlanDefaultNotListedError";
+  }
+}
+async function casePlanDefaults2(fs, contentFolder) {
+  const casePlanFileName = findCasePlanFileName2(await fs.readdir(contentFolder));
+  if (!casePlanFileName)
+    return;
+  const plan = (await readJsonObjectFile(fs, Path.join(contentFolder, casePlanFileName)))?.value;
+  if (!plan)
+    return;
+  return (entryPoints) => withCasePlanDefaults2(entryPoints, plan, casePlanFileName);
+}
+
+// ../packager/packager-tool-case/src/case-tool.ts
+var CaseConstants = {
+  EntryPointsFileName: "entry-points.json"
+};
+
+class CaseTool extends ProjectTool {
+  _temporaryStorage;
+  constructor(fileSystem, logger) {
+    super(fileSystem, logger);
+    this._temporaryStorage = new TemporaryStorageService(fileSystem);
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info("Restore operation is not required for Case Management projects");
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info("Validate operation is not required for Case Management projects");
+    return ToolResult.success();
+  }
+  async buildAsync(options, _cancellationToken) {
+    const tempFolder = await this._temporaryStorage.getTempFolderPath();
+    const localBuildFolder = Path.join(tempFolder, NugetConstants.OutputFolderName);
+    const contentFolder = Path.join(localBuildFolder, NugetConstants.ContentFolderName);
+    try {
+      this.logger.progress("Copying files...");
+      await this.copyFiles(options.projectPath, contentFolder);
+      try {
+        await applyDefaultEntryPoint(this.fileSystem, {
+          contentFolder,
+          withDefaults: await casePlanDefaults2(this.fileSystem, contentFolder)
+        });
+      } catch (error) {
+        if (!(error instanceof CasePlanDefaultNotListedError)) {
+          throw error;
+        }
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, error.message);
+      }
+      await this.reconcileRoleBindingNames(contentFolder);
+      this.logger.progress("Compiling case plan to BPMN...");
+      const compileResult = await this.compileCasePlan(options.projectPath, contentFolder);
+      if (!compileResult.isSuccess) {
+        return compileResult;
+      }
+      this.logger.progress("Creating operate.json file...");
+      await this.createOperateFile(options, contentFolder);
+      this.logger.progress("Creating package-descriptor.json file...");
+      await this.createPackageDescriptor(localBuildFolder, contentFolder);
+      return new ToolResult("SUCCESS" /* Success */, "done", [
+        localBuildFolder
+      ]);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.toString() : String(error);
+      this.logger.error(errorMessage);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, "An error occurred while building Case Management project files");
+    }
+  }
+  async packAsync(options, cancellationToken) {
+    const buildResult = await this.buildAsync(options, cancellationToken);
+    if (!buildResult.isSuccess) {
+      return buildResult;
+    }
+    const localBuildFolder = buildResult.packages[0];
+    try {
+      this.logger.progress("Creating NuGet package...");
+      const nupkgFileName = `${options.package.id}.${options.package.version}.nupkg`;
+      const nupkgPath = Path.join(options.outputPath, nupkgFileName);
+      const packager = new NugetPackager(this.fileSystem);
+      const result = await packager.packAsync(localBuildFolder, options.package, nupkgPath);
+      this.logger.progress("Package created successfully");
+      return new ToolResult("SUCCESS" /* Success */, "done", [
+        result.outputPath
+      ]);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.toString() : String(error);
+      this.logger.error(errorMessage);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, "An error occurred while packing Case Management project");
+    }
+  }
+  async dispose() {
+    this.logger.info("Disposing Case Management Tool");
+    try {
+      await this._temporaryStorage.cleanup();
+    } catch {}
+  }
+  async reconcileRoleBindingNames(contentFolder) {
+    const planName = findCasePlanFileName2(await this.fileSystem.readdir(contentFolder));
+    if (planName === undefined)
+      return;
+    const bindingsPath = Path.join(contentFolder, "bindings_v2.json");
+    const plan = await this.readJson(Path.join(contentFolder, planName));
+    const file = await this.readJson(bindingsPath);
+    if (!isRecord3(file) || !Array.isArray(file.resources))
+      return;
+    const { resources, changed } = reconcileRoleBindings(file.resources, readCaseRoles(plan));
+    if (!changed)
+      return;
+    await this.fileSystem.writeFile(bindingsPath, `${JSON.stringify({ ...file, resources }, null, 2)}
+`);
+  }
+  async readJson(path) {
+    try {
+      const raw = await this.fileSystem.readFile(path);
+      return raw && raw.length > 0 ? JSON.parse(new TextDecoder().decode(raw)) : undefined;
+    } catch {
+      return;
+    }
+  }
+  async copyFiles(sourcePath, contentFolder) {
+    await this.fileSystem.mkdir(contentFolder);
+    const files = await this.fileSystem.readdir(sourcePath);
+    for (const file of files) {
+      const sourceFile = Path.join(sourcePath, file);
+      const stat = await this.fileSystem.stat(sourceFile);
+      if (stat?.isFile()) {
+        const content = await this.fileSystem.readFile(sourceFile);
+        if (content) {
+          const destinationFile = Path.join(contentFolder, file);
+          await this.fileSystem.writeFile(destinationFile, content);
+        }
+      }
+    }
+  }
+  async compileCasePlan(projectPath, contentFolder) {
+    const compile = getCaseBpmnCompiler();
+    const casePlanFileName = findCasePlanFileName2(await this.fileSystem.readdir(projectPath));
+    if (!compile || !casePlanFileName) {
+      return this.checkEntryPointBpmnPresent(contentFolder, casePlanFileName);
+    }
+    const sidecarFileName = casePlanSidecarName2(casePlanFileName);
+    const casePlanPath = Path.join(projectPath, casePlanFileName);
+    const casePlan = await this.fileSystem.readFile(casePlanPath);
+    if (!casePlan || casePlan.length === 0) {
+      return ToolResult.error("INTERNAL_ERROR" /* 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, 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("INTERNAL_ERROR" /* 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, casePlanFileName) {
+    const referenced = await this.readEntryPointBpmnFiles(contentFolder);
+    if (referenced === null) {
+      return ToolResult.error("INTERNAL_ERROR" /* 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 ? casePlanSidecarName2(casePlanFileName) : undefined;
+    const fix = own ?? `Author a case plan (${CasePlanFileNames2.join(", ")}) so pack can compile it (see 'uip maestro case init'), then pack again.`;
+    const staged = await this.stagedMain(contentFolder);
+    const mainEntry = resolveDeclaredFileName2(staged.filePath);
+    if (staged.filePath && !referenced.includes(mainEntry)) {
+      const wording = stagedMainProblem2(staged, mainEntry, own);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `${wording.problem}, which is not a declared .bpmn file this project ships, so the package's main would name a file pack cannot produce. ${wording.fix ? `${wording.fix}, then pack again.` : fix}`);
+    }
+    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 = misnamedEntryPointBpmn2(referenced, casePlanFileName);
+        if (misnamed) {
+          return ToolResult.error("INTERNAL_ERROR" /* 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 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("INTERNAL_ERROR" /* 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);
+    if (!await this.fileSystem.exists(entryPointsPath)) {
+      return [];
+    }
+    const raw = await this.fileSystem.readFile(entryPointsPath);
+    if (!raw || raw.length === 0) {
+      return null;
+    }
+    return entryPointBpmnNames2(new TextDecoder().decode(raw));
+  }
+  async stagedMain(contentFolder) {
+    const read = async (name) => {
+      const raw = await this.fileSystem.readFile(Path.join(contentFolder, name));
+      return raw ? new TextDecoder().decode(raw) : null;
+    };
+    const entryPoints = await read(CaseConstants.EntryPointsFileName);
+    if (entryPoints === null) {
+      return { filePath: "", source: "entry-points.json" };
+    }
+    return stagedMainEntryPoint2(await read(NugetConstants.OperateFileName), entryPoints);
+  }
+  async createOperateFile(options, contentFolder) {
+    await ensureContentOperateFile(this.fileSystem, {
+      contentFolder,
+      projectPath: options.projectPath,
+      projectStorageId: options.projectStorageId,
+      contentType: "CaseManagement" /* CaseManagement */
+    });
+  }
+  async createPackageDescriptor(localBuildFolder, contentFolder) {
+    const contentFiles = await this.fileSystem.readdir(contentFolder);
+    const packageDescriptorPath = Path.join(localBuildFolder, NugetConstants.ContentFolderName, NugetConstants.PackageDescriptorFileName);
+    const packageDescriptorJson = JSON.stringify(buildCasePackageDescriptor2(contentFiles), null, 2);
+    await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
+  }
+}
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+
+// ../packager/packager-tool-case/src/case-tool-factory.ts
+class CaseToolFactory2 {
+  supportedTypes = [
+    "CaseManagement" /* CaseManagement */
+  ];
+  async createAsync(logger, fileSystem) {
+    return new CaseTool(fileSystem, logger);
+  }
+  async describeResourcesAsync(projectDir, fileSystem) {
+    return describeCaseRoles(projectDir, fileSystem);
+  }
+}
+
+// ../packager/packager-tool-case/src/index.ts
+toolsFactoryRepository.registerProjectToolFactory(new CaseToolFactory2);
+export { CasePlanFileNames2, casePlanSidecarName2, findCasePlanFileName2, resolveDeclaredFileName2, normalizeEntryPointPath2, entryPointBpmnNames2, misnamedEntryPointBpmn2, stagedMainEntryPoint2, stagedMainProblem2, buildCasePackageDescriptor2, registerCaseBpmnCompiler, readCasePlanTriggers2, withCasePlanDefaults2, casePlanDefaults2, CaseToolFactory2 };
+
+//# debugId=635649467B9FF67964756E2164756E21

package/dist/{packager-tool-9kvkzc05.js → packager-tool-5w0gjcck.js}

@@ -1,6 +1,6 @@
 import {
   norm
-} from "./packager-tool-9y1w2wds.js";
+} from "./packager-tool-fcektt1g.js";
 
 // src/services/sdd-convert/ids.ts
 var buildElementId = (stageId, taskId) => `${stageId}-${taskId}`;
@@ -54,7 +54,7 @@ var lookupOutput = (index, key, task) => {
   const byTask = index.get(key);
   if (byTask === undefined)
     return;
-  const tasksNamed = (name, claim2) => typeof claim2 === "number" ? Array.from({ length: claim2 }, () => name) : [name];
+  const tasksNamed = (name, claim) => typeof claim === "number" ? Array.from({ length: claim }, () => name) : [name];
   const exact = byTask.get(exactKey(task));
   if (exact !== undefined) {
     return typeof exact === "number" ? { names: tasksNamed(exactKey(task), exact) } : { id: exact };
@@ -64,11 +64,11 @@ var lookupOutput = (index, key, task) => {
     return { id: only };
   }
   return {
-    names: [...byTask].flatMap(([name, claim2]) => tasksNamed(name, claim2))
+    names: [...byTask].flatMap(([name, claim]) => tasksNamed(name, claim))
   };
 };
 var scopedSlaKey = (scope, title) => `${scope}\x00${title}`;
 
 export { buildElementId, stageSpellings, referenceSpellings, indexKey, modelKey, everySpelling, claim, dedupedId, exactKey, claimOutput, lookupOutput, scopedSlaKey };
 
-//# debugId=B8215854508DC8A764756E2164756E21
+//# debugId=BD365DF596F4401564756E2164756E21

package/dist/packager-tool-68648y3j.js

@@ -0,0 +1,6 @@
+// ../integrationservice-sdk/src/dap/activity-configuration-version.ts
+var ACTIVITY_CONFIGURATION_VERSION = "activityConfigurationVersion";
+var v2ConfigurationVersionEntry = () => ({ name: ACTIVITY_CONFIGURATION_VERSION, type: "string", value: "v2" });
+export { v2ConfigurationVersionEntry };
+
+//# debugId=F8F1CE42F97C860064756E2164756E21

package/dist/{packager-tool-1yh8g550.js → packager-tool-6an893wm.js}

@@ -18,7 +18,7 @@ var __toESM = (mod, isNodeMode, target) => {
       return cached;
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   if (mod && typeof mod === "object" || typeof mod === "function") {
     for (let key of __getOwnPropNames(mod))
       if (!__hasOwnProp.call(to, key))
@@ -45,8 +45,17 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+var __exportCjs = (target, getters, setters) => {
+  for (var name in getters)
+    __defProp(target, name, {
+      get: getters[name],
+      set: setters[name],
+      enumerable: true,
+      configurable: true
+    });
+};
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-export { __toESM, __commonJS, __export, __require };
+export { __toESM, __commonJS, __export, __exportCjs, __require };
 
-//# debugId=7B09EB233830E89F64756E2164756E21
+//# debugId=6238031C22BFDF8D64756E2164756E21