@uipath/maestro-tool 1.202.2 → 1.203.0-preview.180

package/dist/{bpmn-refresh-service-ew545y06.js → bpmn-refresh-service-ak1ctkwg.js}

@@ -1,11 +1,11 @@
 import {
   BpmnValidateService
-} from "./packager-tool-kg5sxneg.js";
-import"./packager-tool-jfv7t0c8.js";
+} from "./packager-tool-cmzzh4f8.js";
+import"./packager-tool-kb554twx.js";
 import {
   extractErrorMessageSync,
   isGuid
-} from "./packager-tool-79gws1zn.js";
+} from "./packager-tool-z6nkdv48.js";
 import {
   getFileSystem
 } from "./packager-tool-0v3s8r01.js";
@@ -19,7 +19,7 @@ import {
   parseBpmnProcesses,
   parseJson,
   parseOptionalJson
-} from "./packager-tool-ve35117x.js";
+} from "./packager-tool-mjz4hma1.js";
 import"./packager-tool-1yh8g550.js";
 
 // src/services/bpmn-refresh-service.ts

package/dist/{bpmn-update-metadata-service-jhahhjab.js → bpmn-update-metadata-service-hqe4edze.js}

@@ -2,12 +2,12 @@ import {
   entryPointFilePath,
   extractEntryPointId,
   parseBpmnFile
-} from "./packager-tool-xtv236p7.js";
+} from "./packager-tool-x0eamrk4.js";
 import {
   OutputFormatter,
   RESULTS,
   catchError
-} from "./packager-tool-79gws1zn.js";
+} from "./packager-tool-z6nkdv48.js";
 import {
   getFileSystem
 } from "./packager-tool-0v3s8r01.js";
@@ -57,11 +57,12 @@ function extractUipathVariables(processes) {
 }
 function deriveExpected(processes, bpmnFileName) {
   const allStartEvents = processes.flatMap((p) => (p.flowElements ?? []).filter((e) => e.$type === "bpmn:StartEvent"));
+  const rootEndEventIds = new Set(processes.flatMap((p) => p.flowElements ?? []).filter((e) => e.$type === "bpmn:EndEvent").map((e) => e.id).filter((id) => Boolean(id)));
   const allVars = extractUipathVariables(processes);
   const projectName = bpmnFileName.replace(/\.bpmn$/i, "");
   const outputProps = {};
   for (const v of allVars) {
-    if (!v.elementId && (v.tag === "output" || v.tag === "inputOutput")) {
+    if (v.tag === "output" && v.elementId && rootEndEventIds.has(v.elementId)) {
       outputProps[v.name] = v.schema;
     }
   }
@@ -76,7 +77,7 @@ function deriveExpected(processes, bpmnFileName) {
       firstFilePath = fp;
     const inputProps = {};
     for (const v of allVars) {
-      if (v.elementId === start.id) {
+      if (v.tag === "input" && v.elementId === start.id) {
         inputProps[v.name] = v.schema;
       }
     }
@@ -385,4 +386,4 @@ export {
   UPDATE_METADATA_DEPRECATION
 };
 
-//# debugId=011E83574B25B9C164756E2164756E21
+//# debugId=06F1D70C7A98D0EA64756E2164756E21

package/dist/{bpmn-validate-service-6z2dj8ac.js → bpmn-validate-service-48sfy3a2.js}

@@ -1,8 +1,8 @@
 import {
   BpmnValidateService
-} from "./packager-tool-kg5sxneg.js";
-import"./packager-tool-jfv7t0c8.js";
-import"./packager-tool-79gws1zn.js";
+} from "./packager-tool-cmzzh4f8.js";
+import"./packager-tool-kb554twx.js";
+import"./packager-tool-z6nkdv48.js";
 import"./packager-tool-0v3s8r01.js";
 import"./packager-tool-1yh8g550.js";
 export {

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

@@ -1,21 +1,21 @@
 import {
   parseJsonInputOrFile
-} from "./packager-tool-s1r7krkp.js";
+} from "./packager-tool-9pccpz3r.js";
 import"./packager-tool-eypvc2kv.js";
 import {
   JobsApi,
   ReleasesApi,
   createOrchestratorConfig,
   resolveFolder
-} from "./packager-tool-d5mjdpbf.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-79gws1zn.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-58gtqznh.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-s1466723.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