@uipath/maestro-tool 1.202.1 → 1.203.0-preview.160

package/dist/{case-api-04304252.js → case-api-e3fmq685.js}

@@ -1,21 +1,21 @@
 import {
   parseJsonInputOrFile
-} from "./packager-tool-3hjbc16b.js";
+} from "./packager-tool-9pccpz3r.js";
 import"./packager-tool-eypvc2kv.js";
 import {
   JobsApi,
   ReleasesApi,
   createOrchestratorConfig,
   resolveFolder
-} from "./packager-tool-jm7twdzq.js";
-import"./packager-tool-f0kd5kq4.js";
+} from "./packager-tool-4r35ye9r.js";
+import"./packager-tool-yrsrzz1a.js";
 import"./packager-tool-0gctz400.js";
 import"./packager-tool-qa9gftnj.js";
 import"./packager-tool-yc4kw997.js";
 import {
   OutputFormatter,
   catchError
-} from "./packager-tool-r7rp3zz3.js";
+} from "./packager-tool-z6nkdv48.js";
 import"./packager-tool-0v3s8r01.js";
 import"./packager-tool-1yh8g550.js";
 
@@ -289,7 +289,7 @@ async function getJobStatusDetailed(config, jobKey) {
     throw new Error(`Invalid job key format: "${jobKey}"`);
   }
   const response = await jobsApi.jobsGet({
-    $filter: `Key eq '${jobKey}'`,
+    $filter: `Key eq ${jobKey}`,
     $expand: "Robot,Release,Machine",
     $top: 1
   });
@@ -378,4 +378,4 @@ export {
   validateCaseInputs
 };
 
-//# debugId=3057CB3247490B1864756E2164756E21
+//# debugId=51B8C5ED98C19BFC64756E2164756E21

package/dist/case-bindings-service-nswc6v0v.js

@@ -0,0 +1,240 @@
+import {
+  catchError
+} from "./packager-tool-z6nkdv48.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+import"./packager-tool-1yh8g550.js";
+
+// ../case-tool/src/services/bindings-v2.ts
+var BINDINGS_V2_FILE_NAME = "bindings_v2.json";
+var BINDINGS_V2_VERSION = "2.0";
+var CONNECTION_ID_PROPERTY = "ConnectionId";
+var FOLDER_KEY_PROPERTY = "folderKey";
+var byCodeUnit = (left, right) => {
+  if (left < right)
+    return -1;
+  return left > right ? 1 : 0;
+};
+var sortBindingsV2Resources = (resources) => [...resources].sort((a, b) => byCodeUnit(a.resource, b.resource) || byCodeUnit(a.key, b.key));
+var serializeBindingsV2File = (resources) => {
+  const file = {
+    version: BINDINGS_V2_VERSION,
+    resources: sortBindingsV2Resources(resources)
+  };
+  return `${JSON.stringify(file, null, 2)}
+`;
+};
+var readBindingsV2Resources = (raw) => {
+  const [error, parsed] = catchError(() => JSON.parse(raw));
+  if (error)
+    return;
+  if (parsed === null || typeof parsed !== "object")
+    return;
+  const resources = parsed.resources;
+  if (!Array.isArray(resources))
+    return;
+  return resources.filter((entry) => entry !== null && typeof entry === "object" && typeof entry.key === "string");
+};
+var identity = (entry) => `${entry.resource}:${entry.key}`;
+var diffBindingsV2 = (expected, actual) => {
+  const expectedByKey = new Map(expected.map((e) => [identity(e), e]));
+  const actualByKey = new Map(actual.map((e) => [identity(e), e]));
+  const missing = [];
+  const changed = [];
+  for (const [key, entry] of expectedByKey) {
+    const found = actualByKey.get(key);
+    if (found === undefined) {
+      missing.push(entry.key);
+    } else if (JSON.stringify(found) !== JSON.stringify(entry)) {
+      changed.push(entry.key);
+    }
+  }
+  const extra = [...actualByKey.values()].filter((entry) => !expectedByKey.has(identity(entry))).map((entry) => entry.key);
+  const alphabetically = (left, right) => left.localeCompare(right);
+  return {
+    missing: missing.sort(alphabetically),
+    extra: extra.sort(alphabetically),
+    changed: changed.sort(alphabetically)
+  };
+};
+var hasBindingsV2Difference = (difference) => difference.missing.length > 0 || difference.extra.length > 0 || difference.changed.length > 0;
+
+// ../case-tool/src/services/case-bindings-service.ts
+var asBinding = (value) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  const record = value;
+  return typeof record.id === "string" && typeof record.resource === "string" && typeof record.resourceKey === "string" && record.resourceKey !== "" && typeof record.propertyAttribute === "string" && (record.default === undefined || typeof record.default === "string") ? value : undefined;
+};
+var CONNECTION_RESOURCE = "Connection";
+var NAME_ATTRIBUTE = "name";
+var FOLDER_PATH_ATTRIBUTE = "folderPath";
+var SOLUTION_FOLDER_PREFIX = "solution_folder.";
+var SOLUTION_FOLDER_SENTINEL = "solution_folder";
+var BINDING_REFERENCE_PREFIX = "=bindings.";
+var CONNECTOR_KEY_ENTRY = "connectorKey";
+var CONNECTION_ENTRY = "connection";
+var readConnectorContext = (value) => {
+  if (!Array.isArray(value))
+    return;
+  const byName = new Map;
+  for (const entry of value) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+      return;
+    const { name, value: entryValue } = entry;
+    if (typeof name !== "string")
+      return;
+    if (typeof entryValue === "string")
+      byName.set(name, entryValue);
+  }
+  return byName.has(CONNECTOR_KEY_ENTRY) ? byName : undefined;
+};
+var collectConnectorKeys = (document) => {
+  const byBindingId = new Map;
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      const context = readConnectorContext(node);
+      const connection = context?.get(CONNECTION_ENTRY);
+      const connectorKey = context?.get(CONNECTOR_KEY_ENTRY);
+      if (connectorKey !== undefined && connection?.startsWith(BINDING_REFERENCE_PREFIX) === true) {
+        byBindingId.set(connection.slice(BINDING_REFERENCE_PREFIX.length), connectorKey);
+      }
+      for (const item of node)
+        visit(item);
+      return;
+    }
+    if (node === null || typeof node !== "object")
+      return;
+    for (const value of Object.values(node))
+      visit(value);
+  };
+  visit(document);
+  return byBindingId;
+};
+var attributeDefault = (group, attribute) => group.find((binding) => binding.propertyAttribute === attribute)?.default;
+var connectionEntry = (group, connectorKeys) => {
+  const key = group[0].resourceKey;
+  const value = {
+    [CONNECTION_ID_PROPERTY]: {
+      defaultValue: attributeDefault(group, CONNECTION_ID_PROPERTY) ?? key
+    }
+  };
+  const folderKey = attributeDefault(group, FOLDER_KEY_PROPERTY);
+  if (folderKey !== undefined) {
+    value[FOLDER_KEY_PROPERTY] = { defaultValue: folderKey };
+  }
+  const connector = group.map((binding) => connectorKeys.get(binding.id)).find((found) => found !== undefined);
+  return {
+    resource: CONNECTION_RESOURCE,
+    key,
+    value,
+    ...connector !== undefined && { metadata: { connector } }
+  };
+};
+var resourceEntry = (group) => {
+  const key = group[0].resourceKey;
+  const value = {};
+  const name = attributeDefault(group, NAME_ATTRIBUTE);
+  if (name !== undefined)
+    value.name = { defaultValue: name };
+  const folderPath = key.startsWith(SOLUTION_FOLDER_PREFIX) ? SOLUTION_FOLDER_SENTINEL : attributeDefault(group, FOLDER_PATH_ATTRIBUTE);
+  if (folderPath !== undefined) {
+    value.folderPath = { defaultValue: folderPath };
+  }
+  const subType = group.find((binding) => binding.resourceSubType !== undefined)?.resourceSubType;
+  return {
+    resource: group[0].resource,
+    key,
+    value,
+    ...subType !== undefined && { metadata: { subType } }
+  };
+};
+var deriveCaseBindingsV2 = (document) => {
+  const connectorKeys = collectConnectorKeys(document);
+  const groups = new Map;
+  for (const entry of Array.isArray(document.bindings) ? document.bindings : []) {
+    const binding = asBinding(entry);
+    if (binding === undefined)
+      continue;
+    const groupKey = `${binding.resource}:${binding.resourceKey}`;
+    const group = groups.get(groupKey);
+    if (group === undefined)
+      groups.set(groupKey, [binding]);
+    else
+      group.push(binding);
+  }
+  return [...groups.values()].map((group) => group[0].resource === CONNECTION_RESOURCE ? connectionEntry(group, connectorKeys) : resourceEntry(group));
+};
+var bindingsV2PathFor = (casePlanPath) => {
+  const fs = getFileSystem();
+  return fs.path.join(fs.path.dirname(fs.path.resolve(casePlanPath)), BINDINGS_V2_FILE_NAME);
+};
+var compareCaseBindingsV2 = async (casePlanPath, document) => {
+  const fs = getFileSystem();
+  const path = bindingsV2PathFor(casePlanPath);
+  const expected = deriveCaseBindingsV2(document);
+  const expectedCount = expected.length;
+  if (!await fs.exists(path))
+    return { status: "absent", path, expectedCount };
+  const [readError, raw] = await catchError(fs.readFile(path, "utf-8"));
+  if (readError || raw == null)
+    return { status: "unreadable", path, expectedCount };
+  const actual = readBindingsV2Resources(raw);
+  if (actual === undefined)
+    return { status: "unreadable", path, expectedCount };
+  const difference = diffBindingsV2(expected, actual);
+  return hasBindingsV2Difference(difference) ? { status: "differs", path, expectedCount, difference } : { status: "match", path, expectedCount };
+};
+var syncCaseBindings = async (casePlanPath) => {
+  const fs = getFileSystem();
+  const resolved = fs.path.resolve(casePlanPath);
+  if (!await fs.exists(resolved)) {
+    return {
+      ok: false,
+      message: `Case plan file not found: ${resolved}`,
+      instructions: "Pass the path to an existing caseplan JSON file, for example 'uip maestro case bindings sync case.json'."
+    };
+  }
+  const [readError, raw] = await catchError(fs.readFile(resolved, "utf-8"));
+  if (readError || raw == null) {
+    return {
+      ok: false,
+      message: `Failed to read case plan: ${readError?.message ?? "empty content"}`,
+      instructions: `Verify read permissions on ${resolved}.`
+    };
+  }
+  const [parseError, document] = catchError(() => JSON.parse(raw));
+  if (parseError || document == null || typeof document !== "object" || Array.isArray(document)) {
+    return {
+      ok: false,
+      message: `Case plan is not valid JSON: ${parseError?.message ?? "not a JSON object"}`,
+      instructions: `Verify the contents of ${resolved}.`
+    };
+  }
+  const resources = deriveCaseBindingsV2(document);
+  const path = bindingsV2PathFor(resolved);
+  const [writeError] = await catchError(fs.writeFile(path, serializeBindingsV2File(resources)));
+  if (writeError) {
+    return {
+      ok: false,
+      message: `Failed to write bindings file: ${writeError.message}`,
+      instructions: `Verify write permissions on ${fs.path.dirname(path)}.`
+    };
+  }
+  return {
+    ok: true,
+    path,
+    resourceCount: resources.length,
+    connectionCount: resources.filter((entry) => entry.resource === CONNECTION_RESOURCE).length
+  };
+};
+export {
+  bindingsV2PathFor,
+  compareCaseBindingsV2,
+  deriveCaseBindingsV2,
+  syncCaseBindings
+};
+
+//# debugId=B9EB75D4E4B999D964756E2164756E21

package/dist/case-debug-studio-web-service-08wx4631.js

@@ -0,0 +1,135 @@
+import {
+  loadCaseSchemaAsync
+} from "./packager-tool-gvgnfejf.js";
+import {
+  uploadAndDebugSolution
+} from "./packager-tool-095jzn8v.js";
+import"./packager-tool-mj89jhvb.js";
+import {
+  buildSolutionPackageFromDir,
+  uploadOrOverwriteSolution
+} from "./packager-tool-tqct19db.js";
+import {
+  findSolutionFile,
+  updateSolutionFile
+} from "./packager-tool-wynrdnqj.js";
+import {
+  CasePlanFileNames,
+  buildCasePackageDescriptor,
+  casePlanSidecarName,
+  entryPointBpmnNames,
+  findCasePlanFileName,
+  misnamedEntryPointBpmn,
+  normalizeEntryPointPath,
+  resolveDeclaredFileName
+} from "./packager-tool-kj0qc4f4.js";
+import"./packager-tool-khm7zsm8.js";
+import"./packager-tool-nkrmjr3a.js";
+import {
+  logger
+} from "./packager-tool-z6nkdv48.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+import"./packager-tool-1yh8g550.js";
+
+// ../case-tool/src/services/case-debug-studio-web-service.ts
+class CaseDebugStudioWebService {
+  fs;
+  constructor() {
+    this.fs = getFileSystem();
+  }
+  async executeProjectViaStudioWeb(projectPath, config, callbacks, pollInterval) {
+    const absoluteProjectPath = this.fs.path.resolve(projectPath);
+    const projectUiprojPath = this.fs.path.join(absoluteProjectPath, "project.uiproj");
+    if (!await this.fs.exists(projectUiprojPath)) {
+      throw new Error(`Not a valid case project directory: missing project.uiproj in ${absoluteProjectPath}`);
+    }
+    const projectUiprojContent = await this.fs.readFile(projectUiprojPath, "utf-8");
+    if (projectUiprojContent === null) {
+      throw new Error(`Could not read project.uiproj in ${absoluteProjectPath}`);
+    }
+    const projectUiproj = JSON.parse(projectUiprojContent);
+    const projectName = projectUiproj.Name;
+    const entryPointsPath = this.fs.path.join(absoluteProjectPath, "entry-points.json");
+    if (!await this.fs.exists(entryPointsPath)) {
+      throw new Error(`Not a valid case project directory: missing entry-points.json in ${absoluteProjectPath}`);
+    }
+    const entryPointsContent = await this.fs.readFile(entryPointsPath, "utf-8");
+    if (entryPointsContent === null) {
+      throw new Error(`Could not read entry-points.json in ${absoluteProjectPath}`);
+    }
+    const declared = entryPointBpmnNames(entryPointsContent);
+    if (declared === null) {
+      throw new Error(`entry-points.json in ${absoluteProjectPath} could not be read as JSON, so debug cannot check that the BPMN it declares is in the project.`);
+    }
+    const entryPointsJson = JSON.parse(entryPointsContent);
+    const rawEntryPoint = entryPointsJson.entryPoints?.[0]?.filePath ?? "";
+    const entryPoint = normalizeEntryPointPath(rawEntryPoint);
+    logger.info("Looking for .uipx solution file...");
+    const solutionInfo = await findSolutionFile(this.fs, absoluteProjectPath);
+    const existingSolutionId = solutionInfo?.solutionId;
+    logger.info("Reading case plan file...");
+    const casePlanFileName = findCasePlanFileName(await this.fs.readdir(absoluteProjectPath));
+    if (!casePlanFileName) {
+      throw new Error(`Not a valid case project directory: no case plan in ${absoluteProjectPath}. Expected one of ${CasePlanFileNames.join(", ")}.`);
+    }
+    const caseJsonPath = this.fs.path.join(absoluteProjectPath, casePlanFileName);
+    const caseFileContent = await this.fs.readFile(caseJsonPath, "utf-8");
+    if (caseFileContent === null) {
+      throw new Error(`Could not read file: ${caseJsonPath}`);
+    }
+    const sidecarFileName = casePlanSidecarName(casePlanFileName);
+    logger.info("Converting case plan to BPMN and case plan JSON...");
+    const { serializeCaseDiskJsonToBpmnAndRulesJson } = await loadCaseSchemaAsync();
+    const { bpmnXml, rulesJson: casePlanJson } = await serializeCaseDiskJsonToBpmnAndRulesJson(caseFileContent);
+    await this.fs.writeFile(this.fs.path.join(absoluteProjectPath, sidecarFileName), bpmnXml);
+    await this.fs.writeFile(this.fs.path.join(absoluteProjectPath, "case-plan.json"), `${JSON.stringify(casePlanJson, null, 2)}
+`);
+    const projectFiles = new Set([
+      ...await this.fs.readdir(absoluteProjectPath),
+      sidecarFileName
+    ]);
+    const missing = declared.filter((file) => !projectFiles.has(file));
+    if (missing.length > 0) {
+      throw new Error(`entry-points.json points at ${missing.join(", ")}, which ${absoluteProjectPath} does not hold, so the debug run would fault. Point the entry point at '${sidecarFileName}', or add the missing file.`);
+    }
+    const misnamed = misnamedEntryPointBpmn(declared, casePlanFileName);
+    if (misnamed) {
+      throw new Error(`entry-points.json points at '${misnamed}', the sidecar of a case plan this project does not carry. '${casePlanFileName}' compiles to '${sidecarFileName}', so the debug run would resolve a BPMN nothing here produced. Point the entry point at '${sidecarFileName}'.`);
+    }
+    const entryPointFileName = resolveDeclaredFileName(rawEntryPoint);
+    if (!declared.includes(entryPointFileName)) {
+      throw new Error(`entry-points.json's first entry point resolves to '${entryPointFileName || entryPoint}', which is not a declared .bpmn file this project ships, so the debug run would fault. Point the entry point at '${sidecarFileName}'.`);
+    }
+    await this.fs.writeFile(this.fs.path.join(absoluteProjectPath, "package-descriptor.json"), `${JSON.stringify(buildCasePackageDescriptor([...projectFiles]), null, 2)}
+`);
+    logger.info("Building solution package from project...");
+    const solutionDir = this.fs.path.resolve(absoluteProjectPath, "..");
+    const uisPath = await buildSolutionPackageFromDir(this.fs, solutionDir);
+    const apiConfig = {
+      baseUrl: config.baseUrl,
+      organizationId: config.organizationId,
+      tenantName: config.tenantName,
+      tenantId: config.tenantId,
+      authToken: config.authToken,
+      organizationUnitId: config.organizationUnitId
+    };
+    return uploadAndDebugSolution({
+      upload: () => uploadOrOverwriteSolution(apiConfig, config.organizationName, uisPath, existingSolutionId, this.fs),
+      onSolutionId: (id) => updateSolutionFile(this.fs, absoluteProjectPath, id),
+      projectName,
+      entryPoint,
+      projectType: "CaseManagement",
+      apiConfig,
+      organizationName: config.organizationName,
+      callbacks,
+      pollInterval
+    });
+  }
+}
+export {
+  CaseDebugStudioWebService
+};
+
+//# debugId=1A2B4E9D87C979D064756E2164756E21

package/dist/case-format-service-6s5e1ckk.js

@@ -0,0 +1,84 @@
+import {
+  catchError
+} from "./packager-tool-z6nkdv48.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+import"./packager-tool-1yh8g550.js";
+
+// ../case-tool/src/services/case-format-service.ts
+var INDENT = 2;
+var longestLineOf = (text) => {
+  let longest = 0;
+  let current = 0;
+  for (const ch of text) {
+    if (ch === `
+`) {
+      longest = Math.max(longest, current);
+      current = 0;
+      continue;
+    }
+    current += 1;
+  }
+  return Math.max(longest, current);
+};
+var formatCasePlan = async (filePath) => {
+  const fs = getFileSystem();
+  const resolved = fs.path.resolve(filePath);
+  if (!await fs.exists(resolved)) {
+    return {
+      ok: false,
+      message: `Case plan file not found: ${resolved}`,
+      instructions: "Pass the path to an existing case plan JSON file, for example 'uip maestro case format case.json'."
+    };
+  }
+  const [readError, raw] = await catchError(fs.readFile(resolved, "utf-8"));
+  if (readError || raw == null) {
+    return {
+      ok: false,
+      message: `Failed to read case plan: ${readError?.message ?? "empty content"}`,
+      instructions: `Verify read permissions on ${resolved}.`
+    };
+  }
+  const [parseError, document] = catchError(() => JSON.parse(raw));
+  if (parseError) {
+    return {
+      ok: false,
+      message: `Case plan is not valid JSON: ${parseError.message}`,
+      instructions: `Fix the JSON in ${resolved} before formatting it — formatting cannot repair a file it cannot parse.`
+    };
+  }
+  const formatted = `${JSON.stringify(document, null, INDENT)}
+`;
+  if (formatted === raw) {
+    return {
+      ok: true,
+      path: resolved,
+      changed: false,
+      lines: formatted.split(`
+`).length - 1,
+      longestLine: longestLineOf(formatted)
+    };
+  }
+  const [writeError] = await catchError(fs.writeFile(resolved, formatted));
+  if (writeError) {
+    return {
+      ok: false,
+      message: `Failed to write case plan: ${writeError.message}`,
+      instructions: `Verify write permissions on ${resolved}.`
+    };
+  }
+  return {
+    ok: true,
+    path: resolved,
+    changed: true,
+    lines: formatted.split(`
+`).length - 1,
+    longestLine: longestLineOf(formatted)
+  };
+};
+export {
+  formatCasePlan
+};
+
+//# debugId=D1F974DB89BD88FD64756E2164756E21

package/dist/{case-pack-service-jvtttcen.js → case-pack-service-sg435he1.js}

@@ -4,6 +4,16 @@ import {
 import {
   VALID_PACKAGE_NAME_REGEX
 } from "./packager-tool-eypvc2kv.js";
+import {
+  CasePlanFileNames,
+  buildCasePackageDescriptor,
+  casePlanSidecarName,
+  entryPointBpmnNames,
+  findCasePlanFileName,
+  misnamedEntryPointBpmn,
+  resolveDeclaredFileName
+} from "./packager-tool-kj0qc4f4.js";
+import"./packager-tool-khm7zsm8.js";
 import {
   NugetPackager,
   ensureProjectId
@@ -13,7 +23,7 @@ import {
   catchError,
   logger,
   mapPackageMetadataOptions
-} from "./packager-tool-r7rp3zz3.js";
+} from "./packager-tool-z6nkdv48.js";
 import {
   getFileSystem
 } from "./packager-tool-0v3s8r01.js";
@@ -41,7 +51,7 @@ Packing Case project...
     logger.info(`  Output:   ${absoluteOutputPath}`);
     logger.info("");
     await this.validate(absoluteProjectPath);
-    await this.convertCaseToBpmnIfNeeded(absoluteProjectPath);
+    const casePlanFileName = await this.convertCaseToBpmn(absoluteProjectPath);
     await ensureProjectId(absoluteProjectPath, this.fs);
     await this.fs.mkdir(absoluteOutputPath);
     let tempDir;
@@ -49,7 +59,10 @@ Packing Case project...
       tempDir = await this.fs.getTempDir();
       const stagingDir = this.fs.path.join(tempDir, "case-pack-staging");
       await this.fs.mkdir(stagingDir);
-      await this.fs.copyDirectory(absoluteProjectPath, this.fs.path.join(stagingDir, "content"));
+      const contentDir = this.fs.path.join(stagingDir, "content");
+      await this.fs.copyDirectory(absoluteProjectPath, contentDir);
+      await this.checkEntryPointBpmn(contentDir, casePlanFileName);
+      await this.regeneratePackageDescriptor(contentDir);
       const packageId = `${packageName}.case.Case`;
       const version = options.version || "1.0.0";
       const nupkgPath = this.fs.path.join(absoluteOutputPath, `${packageId}.${version}.nupkg`);
@@ -74,18 +87,51 @@ Packing Case project...
       }
     }
   }
-  async convertCaseToBpmnIfNeeded(projectPath) {
-    const caseFilePath = this.fs.path.join(projectPath, "caseplan.json");
-    if (!await this.fs.exists(caseFilePath)) {
-      return;
+  async convertCaseToBpmn(projectPath) {
+    const casePlanFileName = findCasePlanFileName(await this.fs.readdir(projectPath));
+    if (!casePlanFileName) {
+      throw new Error(`No case plan in ${projectPath}. Expected one of ${CasePlanFileNames.join(", ")}.`);
     }
-    logger.info("Converting case JSON to BPMN...");
-    const caseContent = String(await this.fs.readFile(caseFilePath, "utf-8"));
+    logger.info("Converting case plan to BPMN...");
+    const caseContent = String(await this.fs.readFile(this.fs.path.join(projectPath, casePlanFileName), "utf-8"));
     const { serializeCaseDiskJsonToBpmnAndRulesJson } = await loadCaseSchemaAsync();
     const { bpmnXml: bpmn } = await serializeCaseDiskJsonToBpmnAndRulesJson(caseContent);
-    const bpmnFilePath = this.fs.path.join(projectPath, "caseplan.json.bpmn");
+    const bpmnFilePath = this.fs.path.join(projectPath, casePlanSidecarName(casePlanFileName));
     await this.fs.writeFile(bpmnFilePath, bpmn);
     logger.info(`BPMN file written to ${bpmnFilePath}`);
+    return casePlanFileName;
+  }
+  async checkEntryPointBpmn(contentPath, casePlanFileName) {
+    const entryPointsPath = this.fs.path.join(contentPath, "entry-points.json");
+    if (!await this.fs.exists(entryPointsPath)) {
+      return;
+    }
+    const raw = await this.fs.readFile(entryPointsPath, "utf-8");
+    const declared = raw ? entryPointBpmnNames(String(raw)) : null;
+    if (declared === null) {
+      throw new Error(`entry-points.json in ${contentPath} could not be read as JSON, so pack cannot check that the BPMN it declares is in the package.`);
+    }
+    const firstEntry = firstEntryPointFileName(String(raw));
+    if (firstEntry && !declared.includes(firstEntry)) {
+      const own = casePlanSidecarName(casePlanFileName);
+      throw new Error(`entry-points.json's first entry point resolves to '${firstEntry}', which is not a declared .bpmn file this project ships, so it would deploy and activate and then fault every job. Point the first entry point at '${own}'.`);
+    }
+    const present = new Set(await this.fs.readdir(contentPath));
+    const missing = declared.filter((file) => !present.has(file));
+    if (missing.length > 0) {
+      throw new Error(`entry-points.json points at ${missing.join(", ")}, which the package does not contain, so it would deploy and activate and then fault every job.`);
+    }
+    const misnamed = misnamedEntryPointBpmn(declared, casePlanFileName);
+    if (misnamed) {
+      const own = casePlanSidecarName(casePlanFileName);
+      throw new Error(`entry-points.json points at '${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}'.`);
+    }
+  }
+  async regeneratePackageDescriptor(contentDir) {
+    const contentFiles = await this.fs.readdir(contentDir);
+    const descriptor = buildCasePackageDescriptor(contentFiles);
+    await this.fs.writeFile(this.fs.path.join(contentDir, "package-descriptor.json"), `${JSON.stringify(descriptor, null, 2)}
+`);
   }
   async validate(projectPath) {
     if (!await this.fs.exists(projectPath)) {
@@ -105,8 +151,13 @@ Packing Case project...
     }
   }
 }
+function firstEntryPointFileName(entryPointsJson) {
+  const parsed = JSON.parse(entryPointsJson);
+  const filePath = parsed.entryPoints?.[0]?.filePath ?? "";
+  return resolveDeclaredFileName(filePath);
+}
 export {
   CasePackService
 };
 
-//# debugId=0A0FF64BCBA02D9C64756E2164756E21
+//# debugId=C887ABF9EFDF391264756E2164756E21