@uipath/case-tool 1.203.0-preview.212 → 1.204.0-preview.211

package/README.md

@@ -22,6 +22,10 @@ All commands are available under the `case` prefix:
 uip maestro case <command>
 ```
 
+`case compile`, `case check`, `case decompile` and `case merge` run the
+project's builder SDK (`@uipath/maestro-builder-sdk`); see
+[Authoring commands](../maestro-tool/README.md#authoring-commands).
+
 ### `registry pull`
 
 Fetch and cache all resource types from the UiPath platform.
@@ -45,6 +49,7 @@ uip maestro case registry pull [options]
 | `api` | API workflows |
 | `processOrchestration` | Agentic processes |
 | `caseManagement` | Case management workflows |
+| `function` | Coded Functions |
 | `typecache-activities` | Connector activities (Integration Service) |
 | `typecache-triggers` | Connector triggers (Integration Service) |
 | `action-apps` | Deployed human action apps |
@@ -288,7 +293,7 @@ Change detection uses SHA-256 hashing — if the fetched data is identical to th
 
 | Resource type | Endpoint |
 | :--- | :--- |
-| `agent`, `process`, `api`, `processOrchestration`, `caseManagement` | `/{accountId}/{tenantId}/resourcecatalog_/Entities/Process?entitySubType=<type>` |
+| `agent`, `process`, `api`, `processOrchestration`, `caseManagement`, `function` | `/{accountId}/{tenantId}/resourcecatalog_/Entities/Process?entitySubType=<type>` |
 | `action-apps` | `/{accountId}/apps_/default/api/v1/default/action-apps?state=deployed` |
 | `typecache-activities` | `/{accountId}/studio_/typecache/api/Activities/SearchActivities` |
 | `typecache-triggers` | `/{accountId}/studio_/typecache/api/Activities/SearchTriggers` |

package/dist/THIRD-PARTY-NOTICES.md

@@ -10,11 +10,11 @@ those licences require.
 - @jsep-plugin/object@1.2.2 — MIT
 - @serverlessworkflow/sdk@1.0.1 — Apache-2.0
 - @uipath/agents-storage-schemas@1.35.0 — see below
-- @uipath/case-schema@0.1052.3 — UNLICENSED
+- @uipath/case-schema@0.1147.0 — SEE LICENSE IN LICENSE.txt
 - @uipath/flow-core@0.115.4-develop — MIT
 - @uipath/flow-schema@0.72.2-develop — MIT
 - @uipath/integration-service-design-time@0.25.2 — see below
-- @uipath/resource-builder-sdk@2025.11.0-alpha5891-4020 — ISC
+- @uipath/resource-builder-sdk@2025.11.0-alpha6004-4107 — ISC
 - acorn@8.17.0 — MIT
 - ajv@8.20.0 — MIT
 - ajv-errors@3.0.0 — MIT
@@ -313,14 +313,15 @@ internal IP policy, and is listed here because it is bundled.
 
 ---
 
-## @uipath/case-schema@0.1052.3
+## @uipath/case-schema@0.1147.0
 
-SPDX: UNLICENSED as declared, cleared for distribution.
+SPDX: SEE LICENSE IN LICENSE.txt
 
-A UiPath package published from another team's registry. It
-ships no licence text and its npm metadata grants nothing, so
-there is no third-party licence to reproduce: it is covered by
-internal IP policy, and is listed here because it is bundled.
+```
+© 2026 UiPath
+Use of this product is subject (a) to the applicable licensing agreement available: https://www.uipath.com/legal/trust-and-security/legal-terms#content-1 and, (b) for paid products listed here https://licensing.uipath.com/: the licensing agreement agreed between you and UiPath.
+(UiPath means UiPath SRL with headquarters at 4 Vasile Alecsandri Str. and 11 Constantin Daniel Str., Building A, floors 5 and 6, District 1, Bucharest 010639, Romania and UiPath Inc. with principal place of business: One Vanderbilt Avenue, 60th Floor, New York, NY 10017)
+```
 
 ---
 
@@ -355,7 +356,7 @@ internal IP policy, and is listed here because it is bundled.
 
 ---
 
-## @uipath/resource-builder-sdk@2025.11.0-alpha5891-4020
+## @uipath/resource-builder-sdk@2025.11.0-alpha6004-4107
 
 SPDX: ISC
 

package/dist/authoring-0hr88kff.js

@@ -0,0 +1,623 @@
+import {
+  resolveMaestroRegistry
+} from "./packager-tool-5qghkdd0.js";
+import {
+  Option,
+  OutputFormatter,
+  RESULTS,
+  getOutputSink,
+  pascalCaseDataKeys,
+  processContext
+} from "./packager-tool-58kx79ta.js";
+import {
+  getFileSystem
+} from "./packager-tool-xdxr3ync.js";
+import"./packager-tool-1yh8g550.js";
+
+// ../builder-sdk/src/argv.ts
+function addValue(argv, flag, value) {
+  if (typeof value === "string") {
+    argv.push(flag, value);
+  }
+}
+
+// ../builder-sdk/src/delegate.ts
+import { spawn as spawn2 } from "node:child_process";
+import { createRequire } from "node:module";
+import { StringDecoder } from "node:string_decoder";
+
+// ../builder-sdk/src/npm-global-root.ts
+import { spawn } from "node:child_process";
+var NPM_ROOT_TIMEOUT_MS = 5000;
+var npmRootLookup;
+function npmGlobalRoot() {
+  const prefix = npmConfigPrefix(process.env);
+  if (prefix.trim() !== "") {
+    return Promise.resolve(process.platform === "win32" ? getFileSystem().path.join(prefix, "node_modules") : getFileSystem().path.join(prefix, "lib", "node_modules"));
+  }
+  npmRootLookup ??= runNpmRootGlobal();
+  return npmRootLookup;
+}
+function runNpmRootGlobal() {
+  return new Promise((resolve) => {
+    const stdio = ["ignore", "pipe", "ignore"];
+    const onWindows = { shell: true, stdio, windowsHide: true };
+    const proc = process.platform === "win32" ? spawn("npm root -g", [], onWindows) : spawn("npm", ["root", "-g"], { stdio });
+    let stdout = "";
+    proc.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    const timer = setTimeout(() => {
+      proc.kill("SIGTERM");
+      resolve(null);
+    }, NPM_ROOT_TIMEOUT_MS);
+    proc.on("error", () => {
+      clearTimeout(timer);
+      resolve(null);
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      const root = stdout.trim();
+      resolve(code === 0 && root && !root.includes("***") ? root : null);
+    });
+  });
+}
+function npmConfigPrefix(env) {
+  let prefix = "";
+  for (const [key, value] of Object.entries(env)) {
+    if (key.toLowerCase() === "npm_config_prefix" && value !== undefined) {
+      prefix = value;
+    }
+  }
+  return prefix;
+}
+
+// ../builder-sdk/src/delegate.ts
+var FLOW_SDK_PACKAGE = {
+  name: "@uipath/maestro-builder-sdk",
+  minimumVersion: "6.11.1"
+};
+var BPMN_CONNECTOR_OPTIONS_VERSION = "6.15.0";
+function commandLabel(family, verb) {
+  return `uip maestro ${family} ${verb}`;
+}
+function parseVersion(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(version);
+  if (!match)
+    return null;
+  return [
+    Number(match[1]),
+    Number(match[2]),
+    Number(match[3]),
+    match[4] !== undefined
+  ];
+}
+function versionMeetsFloor(version, floor) {
+  const installed = parseVersion(version);
+  const minimum = parseVersion(floor);
+  if (!installed || !minimum)
+    return false;
+  for (let index = 0;index < 3; index++) {
+    if (installed[index] !== minimum[index]) {
+      return installed[index] > minimum[index];
+    }
+  }
+  return !installed[3] || minimum[3];
+}
+var FLOW_SDK_INVOKED_AS = "uip maestro";
+function resultCode(family, verb) {
+  return [family, verb].map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function stdoutAsData(stdout) {
+  const text = stdout.trimEnd();
+  const trimmed = text.trimStart();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed !== null && typeof parsed === "object") {
+        if (!Array.isArray(parsed) && "ok" in parsed) {
+          const { ok: _ok, ...fields } = parsed;
+          return fields;
+        }
+        return parsed;
+      }
+    } catch {}
+  }
+  return { Output: text };
+}
+function failureReason(out, err) {
+  try {
+    const parsed = JSON.parse(out.trim());
+    if (parsed !== null && typeof parsed === "object" && typeof parsed.error === "string") {
+      return parsed.error;
+    }
+  } catch {}
+  const lines = err.split(`
+`).filter((line) => line.trim() !== "");
+  return lines.at(-1)?.trim() ?? out.trim();
+}
+function spawnSdk(cliPath, args, cwd) {
+  return new Promise((settle) => {
+    let settled = false;
+    const resolve = (outcome) => {
+      if (settled)
+        return;
+      settled = true;
+      settle(outcome);
+    };
+    const child = spawn2("node", [cliPath, ...args], {
+      cwd,
+      env: {
+        ...process.env,
+        FLOW_SDK_INVOKED_AS
+      },
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    const stdout = [];
+    const stderr = [];
+    const decoderErr = new StringDecoder("utf8");
+    const writeLive = (text) => {
+      if (text)
+        getOutputSink().writeErr(text);
+    };
+    child.stdout?.on("data", (chunk) => {
+      stdout.push(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr.push(chunk);
+      writeLive(decoderErr.write(chunk));
+    });
+    child.once("error", (error) => {
+      resolve({ kind: "spawn-error", message: error.message });
+    });
+    child.once("close", (exitCode, signal) => {
+      if (settled)
+        return;
+      writeLive(decoderErr.end());
+      resolve({
+        kind: "closed",
+        exitCode,
+        signal,
+        out: Buffer.concat(stdout).toString("utf-8"),
+        err: Buffer.concat(stderr).toString("utf-8").trim()
+      });
+    });
+  });
+}
+async function runChild(cliPath, args, cwd, label) {
+  const outcome = await spawnSdk(cliPath, args, cwd);
+  if (outcome.kind === "spawn-error") {
+    return {
+      ok: false,
+      exitCode: 1,
+      result: RESULTS.Failure,
+      message: `${label}: ${outcome.message}`,
+      instructions: "Check that node is on PATH, then retry."
+    };
+  }
+  const { exitCode, signal, out, err } = outcome;
+  if (exitCode === 0) {
+    return { ok: true, data: stdoutAsData(out) };
+  }
+  if (exitCode !== null) {
+    const detail = failureReason(out, err) || `SDK exited with code ${exitCode}`;
+    return {
+      ok: false,
+      exitCode,
+      result: RESULTS.Failure,
+      message: `${label}: ${detail}`,
+      instructions: err ? "Fix what the builder SDK reported (on stderr, and in Message), then retry." : "Fix what the builder SDK reported (see Message), then retry.",
+      ...out.trim() ? { data: stdoutAsData(out) } : {}
+    };
+  }
+  return {
+    ok: false,
+    exitCode: 1,
+    result: RESULTS.Failure,
+    message: `${label}: SDK process ended with signal ${signal ?? "unknown"}.`,
+    instructions: "Retry the command."
+  };
+}
+function upgradeInstructions(found) {
+  return found === "workspace" ? `npm install --save-dev ${FLOW_SDK_PACKAGE.name}@latest` : `npm install -g ${FLOW_SDK_PACKAGE.name}@latest`;
+}
+function resolveLocalPackageJson(workspace) {
+  const require2 = createRequire(import.meta.url);
+  try {
+    return require2.resolve(`${FLOW_SDK_PACKAGE.name}/package.json`, {
+      paths: [workspace]
+    });
+  } catch {
+    return null;
+  }
+}
+async function resolveGlobalPackageJson() {
+  const root = await npmGlobalRoot();
+  if (!root)
+    return null;
+  const fs = getFileSystem();
+  const candidate = fs.path.join(root, ...FLOW_SDK_PACKAGE.name.split("/"), "package.json");
+  return await fs.exists(candidate) ? candidate : null;
+}
+async function resolveFlowSdk(workspace, label) {
+  const fs = getFileSystem();
+  const { name, minimumVersion } = FLOW_SDK_PACKAGE;
+  const localPath = resolveLocalPackageJson(workspace);
+  const packagePath = localPath ?? await resolveGlobalPackageJson();
+  const found = localPath ? "workspace" : packagePath ? "global" : "none";
+  if (!packagePath) {
+    return {
+      ok: false,
+      message: `${label}: ${name} is not installed in this workspace or globally.`,
+      instructions: upgradeInstructions(found)
+    };
+  }
+  const packageText = await fs.readFile(packagePath, "utf-8");
+  if (packageText === null) {
+    return {
+      ok: false,
+      message: `${label}: could not read ${packagePath}.`,
+      instructions: `Reinstall ${name}, then retry.`
+    };
+  }
+  let version = "";
+  try {
+    const parsed = JSON.parse(packageText);
+    version = typeof parsed.version === "string" ? parsed.version : "";
+  } catch {
+    version = "";
+  }
+  if (!versionMeetsFloor(version, minimumVersion)) {
+    return {
+      ok: false,
+      message: `${label}: found ${name} ${version || "with no valid version"}; need >= ${minimumVersion}.`,
+      instructions: upgradeInstructions(found)
+    };
+  }
+  return {
+    ok: true,
+    packageDir: fs.path.dirname(packagePath),
+    version,
+    found: found === "workspace" ? "workspace" : "global"
+  };
+}
+async function runFlowSdk({
+  family,
+  commandVerb,
+  sdkVerb = commandVerb,
+  argv,
+  cwd,
+  requiresSdkVersion
+}) {
+  const fs = getFileSystem();
+  const workspace = cwd ?? fs.env.cwd();
+  const label = commandLabel(family, commandVerb);
+  const resolution = await resolveFlowSdk(workspace, label);
+  if (!resolution.ok) {
+    return {
+      ok: false,
+      exitCode: 1,
+      result: RESULTS.ConfigError,
+      message: resolution.message,
+      instructions: resolution.instructions
+    };
+  }
+  if (requiresSdkVersion && !versionMeetsFloor(resolution.version, requiresSdkVersion.version)) {
+    return {
+      ok: false,
+      exitCode: 1,
+      result: RESULTS.ConfigError,
+      message: `${label}: ${requiresSdkVersion.because} needs ${FLOW_SDK_PACKAGE.name} >= ${requiresSdkVersion.version}; found ${resolution.version}.`,
+      instructions: upgradeInstructions(resolution.found)
+    };
+  }
+  const cliPath = fs.path.join(resolution.packageDir, "dist", "cli", "index.js");
+  const sdkArgv = argv.includes("--json") ? [...argv] : [...argv, "--json"];
+  return await runChild(cliPath, [family, sdkVerb, ...sdkArgv], workspace, label);
+}
+async function delegateToFlowSdk(request) {
+  const result = await runFlowSdk(request);
+  if (result.ok) {
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: resultCode(request.family, request.commandVerb),
+      Data: result.data
+    });
+    return 0;
+  }
+  OutputFormatter.error({
+    Result: result.result,
+    Message: result.message,
+    Instructions: result.instructions,
+    ...result.data ? { Data: pascalCaseDataKeys(result.data) } : {}
+  });
+  return result.exitCode;
+}
+
+// ../builder-sdk/src/examples.ts
+function sdkCliExample(family, verb, description, command, data) {
+  return [
+    {
+      Description: description,
+      Command: command,
+      Output: {
+        Code: resultCode(family, verb),
+        Data: data
+      }
+    }
+  ];
+}
+
+// ../builder-sdk/src/library-option.ts
+async function resolveLibraryOption(explicit) {
+  if (explicit !== undefined)
+    return explicit;
+  if (getFileSystem().env.getenv("FLOW_SDK_LIBRARY_JSON"))
+    return;
+  const registry = await resolveMaestroRegistry();
+  return registry?.libraryJson;
+}
+async function connectorLibraryInPlay(explicit) {
+  if (explicit !== undefined)
+    return true;
+  if (getFileSystem().env.getenv("FLOW_SDK_LIBRARY_JSON"))
+    return true;
+  return (await resolveMaestroRegistry())?.libraryJson !== undefined;
+}
+
+// ../builder-sdk/src/commands/check.ts
+var CHECK_EXAMPLES = {
+  flow: { input: "Order.flow.ts" },
+  case: { input: "Claims.case.ts" },
+  bpmn: { input: "Approval.bpmn.ts" }
+};
+var CHECK_RESULT = { Errors: 0, Warnings: 0, Diagnostics: [] };
+var registerCheckCommand = (program, family) => {
+  const command = program.command("check <input>").description("Check a source file for authoring errors before compiling it.").option("--source", "Check authored TypeScript");
+  if (family === "flow" || family === "bpmn") {
+    command.option("--library <dir>", "Connector library directory (defaults to $FLOW_SDK_LIBRARY_JSON, else the pulled library)").option("--connectors-local <dir>", "Connection-resolved connector overlay (default: ./connectors-local)");
+  }
+  if (family === "bpmn") {
+    command.option("--graph", "Also print the resolved wiring: every element with the flows leaving it, implied edges marked ~>");
+  }
+  const example = CHECK_EXAMPLES[family];
+  command.examples(sdkCliExample(family, "check", `Check a ${family} source file before compiling it`, `uip maestro ${family} check ${example.input} --source`, CHECK_RESULT)).trackedAction(processContext, async (input, options) => {
+    const argv = [input];
+    if (options.source)
+      argv.push("--source");
+    const connectorOptions = family === "flow" || family === "bpmn";
+    const library = connectorOptions ? await resolveLibraryOption(options.library) : undefined;
+    addValue(argv, "--library", library);
+    addValue(argv, "--connectors-local", connectorOptions ? options.connectorsLocal : undefined);
+    if (options.graph)
+      argv.push("--graph");
+    const gateBpmnConnectors = family === "bpmn" && (options.connectorsLocal !== undefined || await connectorLibraryInPlay(options.library));
+    const code = await delegateToFlowSdk({
+      family,
+      commandVerb: "check",
+      argv,
+      ...gateBpmnConnectors ? {
+        requiresSdkVersion: {
+          version: BPMN_CONNECTOR_OPTIONS_VERSION,
+          because: "the connector library on bpmn check"
+        }
+      } : {}
+    });
+    if (code !== 0)
+      processContext.exit(code);
+  });
+};
+// ../builder-sdk/src/commands/compile.ts
+var COMPILE_EXAMPLES = {
+  flow: {
+    source: "Order.flow.ts",
+    output: "Order.flow",
+    result: {
+      Path: "/work/Order.flow",
+      Nodes: 3,
+      Edges: 2,
+      Sidecars: [],
+      Errors: 0,
+      Warnings: 0,
+      Diagnostics: []
+    }
+  },
+  case: {
+    source: "Claims.case.ts",
+    output: "caseplan.json",
+    result: { Path: "/work/caseplan.json", Stages: 3 }
+  },
+  bpmn: {
+    source: "Approval.bpmn.ts",
+    output: "Approval.bpmn",
+    result: { Path: "/work/Approval.bpmn", Elements: 4 }
+  }
+};
+var registerCompileCommand = (program, family) => {
+  const command = program.command("compile <source>").description(`Compile authored TypeScript to a ${family} artifact.`).option("-o, --output <file>", "Output artifact path").option("--library <dir>", "Connector library directory (defaults to the pulled registry)").option("--bindings <file>", "bindings.json path").option("--connectors-local <dir>", "Connection-resolved connector overlay (default: ./connectors-local)");
+  if (family === "flow") {
+    command.option("--no-check", "Skip the source-level check");
+  }
+  const example = COMPILE_EXAMPLES[family];
+  command.examples(sdkCliExample(family, "compile", `Compile a ${family} source file to an artifact`, `uip maestro ${family} compile ${example.source} --output ${example.output}`, example.result)).trackedAction(processContext, async (source, options) => {
+    const argv = [source];
+    addValue(argv, "-o", options.output);
+    addValue(argv, "--library", await resolveLibraryOption(options.library));
+    addValue(argv, "--bindings", options.bindings);
+    addValue(argv, "--connectors-local", options.connectorsLocal);
+    if (options.check === false)
+      argv.push("--no-check");
+    const code = await delegateToFlowSdk({
+      family,
+      commandVerb: "compile",
+      argv,
+      ...family === "bpmn" && options.connectorsLocal !== undefined ? {
+        requiresSdkVersion: {
+          version: BPMN_CONNECTOR_OPTIONS_VERSION,
+          because: "--connectors-local on bpmn compile"
+        }
+      } : {}
+    });
+    if (code !== 0)
+      processContext.exit(code);
+  });
+};
+// ../builder-sdk/src/commands/decompile.ts
+var DECOMPILE_EXAMPLES = {
+  flow: {
+    input: "Order.flow",
+    output: "Order.flow.ts",
+    result: {
+      Path: "/work/Order.flow.ts",
+      Pipeline: "/work/Order.pipeline.mjs"
+    }
+  },
+  case: {
+    input: "caseplan.json",
+    output: "Claims.case.ts",
+    result: {
+      Path: "/work/Claims.case.ts",
+      Pipeline: "/work/Claims.pipeline.mjs",
+      Diagnostics: []
+    }
+  },
+  bpmn: {
+    input: "Approval/Approval.bpmn",
+    output: "Approval.bpmn.ts",
+    result: { Path: "/work/Approval.bpmn.ts" },
+    extra: " --style nested"
+  }
+};
+var ARTIFACT = {
+  flow: { artifact: ".flow", source: ".flow.ts" },
+  case: { artifact: "caseplan.json", source: ".case.ts" },
+  bpmn: { artifact: ".bpmn", source: ".bpmn.ts" }
+};
+var registerDecompileCommand = (program, family) => {
+  const command = program.command("decompile <input>").description(`Convert a ${ARTIFACT[family].artifact} artifact to authored TypeScript.`).option("-o, --output <file>", `Output ${ARTIFACT[family].source} path`).option("--import <specifier>", "SDK import specifier in generated source");
+  if (family === "flow") {
+    command.option("--strict", "Fail on unsupported constructs");
+  } else if (family === "case") {
+    command.option("--library <dir>", "Connector library directory (defaults to the pulled registry)").option("--best-effort", "Emit a marked repair scaffold for unsupported constructs");
+  } else {
+    command.addOption(new Option("--style <style>", "explicit (default) or nested: lift boundary events, gateways and event sub-processes into the nesting constructs where the graph is provably the same").choices(["explicit", "nested"]));
+  }
+  if (family !== "bpmn") {
+    command.option("--no-pipeline", "Do not emit a brownfield pipeline helper");
+  }
+  const example = DECOMPILE_EXAMPLES[family];
+  command.examples(sdkCliExample(family, "decompile", `Convert a ${family} artifact back to authored TypeScript`, `uip maestro ${family} decompile ${example.input} --output ${example.output}${example.extra ?? ""}`, example.result)).trackedAction(processContext, async (input, options) => {
+    const argv = [input];
+    addValue(argv, "-o", options.output);
+    addValue(argv, "--import", options.import);
+    if (family === "case") {
+      addValue(argv, "--library", await resolveLibraryOption(options.library));
+    }
+    if (options.strict)
+      argv.push("--strict");
+    if (options.bestEffort)
+      argv.push("--best-effort");
+    if (options.pipeline === false)
+      argv.push("--no-pipeline");
+    addValue(argv, "--style", options.style);
+    const code = await delegateToFlowSdk({
+      family,
+      commandVerb: "decompile",
+      argv
+    });
+    if (code !== 0)
+      processContext.exit(code);
+  });
+};
+// ../builder-sdk/src/named-second.ts
+function namedOrLegacy(spec) {
+  if (spec.named !== undefined && spec.legacy !== undefined) {
+    usageError(`pass ${spec.flag} or a second argument, not both`, spec.usage);
+  }
+  if (spec.named === "") {
+    usageError(`option '${spec.flag}' argument missing`, spec.usage);
+  }
+  if (spec.named !== undefined)
+    return spec.named;
+  if (spec.legacy === undefined) {
+    usageError(`required option '${spec.flag}' not specified`, spec.usage);
+  }
+  getOutputSink().writeErr(`[WARN] The two-argument form is deprecated. Use \`${spec.usage}\` instead.
+`);
+  return spec.legacy;
+}
+function usageError(message, usage) {
+  throw Object.assign(new Error(message), {
+    result: RESULTS.ValidationError,
+    errorCode: "invalid_argument",
+    retry: "RetryWillNotFix",
+    instructions: `Usage: ${usage}`
+  });
+}
+
+// ../builder-sdk/src/commands/merge.ts
+var MERGE_EXAMPLES = {
+  flow: {
+    description: "Merge edited authored content into the original Flow artifact",
+    command: "uip maestro flow merge Edited.flow --original Original.flow --output Merged.flow --baseline Baseline.flow",
+    result: { Path: "/work/Merged.flow", Nodes: 3, Edges: 2 }
+  },
+  case: {
+    description: "Merge edited authored content into the original Case artifact",
+    command: "uip maestro case merge edited.caseplan.json --original original.caseplan.json --output merged.caseplan.json",
+    result: { Path: "/work/merged.caseplan.json", Stages: 3 }
+  },
+  bpmn: {
+    description: "Merge an edited process into the original BPMN artifact, keeping untouched elements byte for byte",
+    command: "uip maestro bpmn merge Edited.bpmn --original Original.bpmn --output Merged.bpmn --baseline Baseline.bpmn",
+    result: {
+      Path: "/work/Merged.bpmn",
+      Preserved: 5,
+      Authored: 1,
+      Removed: 0
+    }
+  }
+};
+var registerMergeCommand = (program, family) => {
+  const command = program.command("merge <edited>").description(`Merge an edited ${family} with its original artifact.`).option("--original <file>", "Original artifact to merge into (required)").option("-o, --output <file>", "Merged output path").allowExcessArguments(true);
+  if (family !== "case") {
+    command.option("--baseline <file>", "Compiled pristine decompile");
+  }
+  const example = MERGE_EXAMPLES[family];
+  command.examples(sdkCliExample(family, "merge", example.description, example.command, example.result)).trackedAction(processContext, async (first, options, cmd) => {
+    const usage = `uip maestro ${family} merge <edited> --original <file>`;
+    if (cmd.args.length > 2) {
+      usageError(`unexpected argument '${cmd.args[2]}'`, usage);
+    }
+    const legacyEdited = cmd.args[1];
+    const original = namedOrLegacy({
+      named: options.original,
+      legacy: legacyEdited === undefined ? undefined : first,
+      flag: "--original",
+      usage
+    });
+    const edited = legacyEdited ?? first;
+    const tail = [];
+    addValue(tail, "-o", options.output);
+    addValue(tail, "--baseline", options.baseline);
+    const code = await delegateToFlowSdk({
+      family,
+      commandVerb: "merge",
+      argv: [edited, "--original", original, ...tail]
+    });
+    if (code !== 0)
+      processContext.exit(code);
+  });
+};
+// src/commands/authoring.ts
+var registerCaseAuthoringCommands = (program) => {
+  registerCompileCommand(program, "case");
+  registerCheckCommand(program, "case");
+  registerDecompileCommand(program, "case");
+  registerMergeCommand(program, "case");
+};
+export {
+  registerCaseAuthoringCommands
+};
+
+//# debugId=A2583E8292E3CD4464756E2164756E21