@camunda8/cli 3.3.0 → 3.4.0-alpha.1

package/dist/default-plugins/element-template/c8ctl-plugin.js

@@ -8059,14 +8059,96 @@ var init_dist4 = __esm({
 });
 
 // default-plugins/element-template/commands/apply.ts
-import { existsSync as existsSync4, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname, resolve as resolvePath3 } from "node:path";
-import { fileURLToPath } from "node:url";
+
+// default-plugins/element-template/moddle.ts
+function isModdleElement(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("get" in value)) {
+    return false;
+  }
+  return typeof value.get === "function";
+}
+function getModdleString(element, name2) {
+  const value = element.get(name2);
+  return typeof value === "string" ? value : void 0;
+}
+function getModdleNumber(element, name2) {
+  const value = element.get(name2);
+  return typeof value === "number" ? value : void 0;
+}
+function getModdleElement(element, name2) {
+  const value = element.get(name2);
+  return isModdleElement(value) ? value : void 0;
+}
+function getModdleList(element, name2) {
+  if (!element) {
+    return [];
+  }
+  const value = element.get(name2);
+  return Array.isArray(value) ? value.filter(isModdleElement) : [];
+}
+
+// default-plugins/element-template/binding.ts
+function findExtensionByType(extensionElements, type) {
+  if (!extensionElements) {
+    return void 0;
+  }
+  const values = getModdleList(extensionElements, "values");
+  return values.find((v) => v.$type === type);
+}
+function findExtensionContainers(extensionElements) {
+  return {
+    ioMapping: findExtensionByType(extensionElements, "zeebe:IoMapping"),
+    taskHeaders: findExtensionByType(extensionElements, "zeebe:TaskHeaders"),
+    taskDefinition: findExtensionByType(
+      extensionElements,
+      "zeebe:TaskDefinition"
+    ),
+    zeebeProperties: findExtensionByType(extensionElements, "zeebe:Properties")
+  };
+}
+function resolveBindingTarget(binding, containers) {
+  switch (binding.type) {
+    case "zeebe:input": {
+      const inputs = getModdleList(containers.ioMapping, "inputParameters");
+      const child = inputs.find((p) => p.target === binding.name);
+      return child ? { child, property: "source" } : void 0;
+    }
+    case "zeebe:output": {
+      const outputs = getModdleList(containers.ioMapping, "outputParameters");
+      const child = outputs.find((p) => p.source === binding.source);
+      return child ? { child, property: "target" } : void 0;
+    }
+    case "zeebe:taskHeader": {
+      const headers = getModdleList(containers.taskHeaders, "values");
+      const child = headers.find((h) => h.key === binding.key);
+      return child ? { child, property: "value" } : void 0;
+    }
+    case "zeebe:property": {
+      const props = getModdleList(containers.zeebeProperties, "properties");
+      const child = props.find((p) => p.name === binding.name);
+      return child ? { child, property: "value" } : void 0;
+    }
+    case "zeebe:taskDefinition": {
+      return containers.taskDefinition && binding.property ? { child: containers.taskDefinition, property: binding.property } : void 0;
+    }
+    default:
+      return void 0;
+  }
+}
 
 // default-plugins/element-template/helpers.ts
 var import_semver = __toESM(require_semver2(), 1);
-import { existsSync, readFileSync } from "node:fs";
+import {
+  existsSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
 import { resolve as resolvePath } from "node:path";
 if (!globalThis.c8ctl) throw new Error("c8ctl runtime not initialised");
 var c8ctl = globalThis.c8ctl;
@@ -8087,6 +8169,25 @@ function installStdoutEpipeHandler() {
 function isRecord(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);
 }
+function atomicOverwriteFile(targetPath, contents) {
+  const target = resolvePath(targetPath);
+  const tmp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    writeFileSync(tmp, contents, "utf-8");
+    renameSync(tmp, target);
+  } catch (error3) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    const code = isRecord(error3) && typeof error3.code === "string" ? error3.code : void 0;
+    if (code === "EXDEV") {
+      writeFileSync(target, contents, "utf-8");
+      return;
+    }
+    throw error3;
+  }
+}
 var ENGINE_VERSION_PATTERN = /^\d+\.\d+(?:\.\d+)?(?:-[0-9A-Za-z.-]+)?$/;
 function isUrl(input) {
   return input.startsWith("https://") || input.startsWith("http://");
@@ -8444,9 +8545,9 @@ import {
   mkdirSync,
   openSync,
   readFileSync as readFileSync2,
-  renameSync,
-  unlinkSync,
-  writeFileSync,
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2,
   writeSync
 } from "node:fs";
 import { join } from "node:path";
@@ -8537,7 +8638,7 @@ function acquireSyncLock(logger) {
       );
     }
     try {
-      unlinkSync(path);
+      unlinkSync2(path);
     } catch {
     }
     if (tryCreateLock(path, payload)) {
@@ -8551,7 +8652,7 @@ function acquireSyncLock(logger) {
 }
 function releaseSyncLock() {
   try {
-    unlinkSync(getSyncLockPath());
+    unlinkSync2(getSyncLockPath());
   } catch {
   }
 }
@@ -8612,11 +8713,11 @@ function loadFetchedAt() {
 function atomicWriteFileSync(target, contents) {
   const tmp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    writeFileSync(tmp, contents, "utf-8");
-    renameSync(tmp, target);
+    writeFileSync2(tmp, contents, "utf-8");
+    renameSync2(tmp, target);
   } catch (error3) {
     try {
-      unlinkSync(tmp);
+      unlinkSync2(tmp);
     } catch {
     }
     throw error3;
@@ -9050,10 +9151,10 @@ async function loadTemplate(templateArg, {
   };
 }
 
-// default-plugins/element-template/commands/apply.ts
-if (!globalThis.c8ctl) throw new Error("c8ctl runtime not initialised");
-var c8ctl3 = globalThis.c8ctl;
-var require2 = createRequire(import.meta.url);
+// default-plugins/element-template/vendor.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { dirname, resolve as resolvePath3 } from "node:path";
+import { fileURLToPath } from "node:url";
 var __dirname = dirname(fileURLToPath(import.meta.url));
 function resolveVendorBundle() {
   const candidates = [
@@ -9061,19 +9162,11 @@ function resolveVendorBundle() {
       __dirname,
       "..",
       "..",
-      "..",
       "dist",
       "vendor",
       "bpmn-element-templates.cjs"
     ),
-    resolvePath3(
-      __dirname,
-      "..",
-      "..",
-      "..",
-      "vendor",
-      "bpmn-element-templates.cjs"
-    )
+    resolvePath3(__dirname, "..", "..", "vendor", "bpmn-element-templates.cjs")
   ];
   for (const path of candidates) {
     if (existsSync4(path)) {
@@ -9085,32 +9178,21 @@ function resolveVendorBundle() {
 Searched: ${candidates.join(", ")}`
   );
 }
-function findExtensionByType(extensionElements, type) {
-  if (!extensionElements) {
-    return void 0;
-  }
-  const values = extensionElements.get("values");
-  return values?.find((v) => v.$type === type);
-}
+
+// default-plugins/element-template/commands/apply.ts
+if (!globalThis.c8ctl) throw new Error("c8ctl runtime not initialised");
+var c8ctl3 = globalThis.c8ctl;
+var require2 = createRequire(import.meta.url);
 function forceSetValues(modeler, element, template, setArgs) {
   const modeling = modeler.get("modeling");
-  const extensionElements = element.businessObject.get("extensionElements");
+  const extensionElements = getModdleElement(
+    element.businessObject,
+    "extensionElements"
+  );
   if (!extensionElements) {
     return;
   }
-  const ioMapping = findExtensionByType(extensionElements, "zeebe:IoMapping");
-  const taskHeaders = findExtensionByType(
-    extensionElements,
-    "zeebe:TaskHeaders"
-  );
-  const taskDefinition = findExtensionByType(
-    extensionElements,
-    "zeebe:TaskDefinition"
-  );
-  const zeebeProperties = findExtensionByType(
-    extensionElements,
-    "zeebe:Properties"
-  );
+  const containers = findExtensionContainers(extensionElements);
   for (const arg of setArgs) {
     const { bindingTypeFilter, name: name2, value } = parseSetArg(arg);
     const matches = findPropertiesByBindingName(
@@ -9119,61 +9201,14 @@ function forceSetValues(modeler, element, template, setArgs) {
       bindingTypeFilter
     );
     for (const prop of matches) {
+      if (!prop.binding) continue;
       const effectiveValue = maybePrependFeel(prop, value);
-      updateModdleForProperty(modeling, element, prop, effectiveValue, {
-        ioMapping,
-        taskHeaders,
-        taskDefinition,
-        zeebeProperties
-      });
-    }
-  }
-}
-function updateModdleForProperty(modeling, element, prop, value, containers) {
-  const binding = prop.binding;
-  if (!binding) {
-    return;
-  }
-  switch (binding.type) {
-    case "zeebe:input": {
-      const inputs = containers.ioMapping?.get("inputParameters") ?? [];
-      const child = inputs.find((p) => p.target === binding.name);
-      if (child) {
-        modeling.updateModdleProperties(element, child, { source: value });
-      }
-      return;
-    }
-    case "zeebe:output": {
-      const outputs = containers.ioMapping?.get("outputParameters") ?? [];
-      const child = outputs.find((p) => p.source === binding.source);
-      if (child) {
-        modeling.updateModdleProperties(element, child, { target: value });
-      }
-      return;
-    }
-    case "zeebe:taskHeader": {
-      const headers = containers.taskHeaders?.get("values") ?? [];
-      const child = headers.find((h) => h.key === binding.key);
-      if (child) {
-        modeling.updateModdleProperties(element, child, { value });
-      }
-      return;
-    }
-    case "zeebe:property": {
-      const props = containers.zeebeProperties?.get("properties") ?? [];
-      const child = props.find((p) => p.name === binding.name);
-      if (child) {
-        modeling.updateModdleProperties(element, child, { value });
-      }
-      return;
-    }
-    case "zeebe:taskDefinition": {
-      if (containers.taskDefinition && binding.property) {
-        modeling.updateModdleProperties(element, containers.taskDefinition, {
-          [binding.property]: value
+      const target = resolveBindingTarget(prop.binding, containers);
+      if (target) {
+        modeling.updateModdleProperties(element, target.child, {
+          [target.property]: effectiveValue
         });
       }
-      return;
     }
   }
 }
@@ -9323,24 +9358,178 @@ async function applySubcommand(args) {
   }
   process.stdout.write(resultXml);
 }
-function atomicOverwriteFile(targetPath, contents) {
-  const target = resolvePath3(targetPath);
-  const tmp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+
+// default-plugins/element-template/commands/edit.ts
+import { createRequire as createRequire2 } from "node:module";
+if (!globalThis.c8ctl) throw new Error("c8ctl runtime not initialised");
+var c8ctl4 = globalThis.c8ctl;
+var require3 = createRequire2(import.meta.url);
+async function planEdit(modeler, elementId, setArgs) {
+  const elementRegistry = modeler.get("elementRegistry");
+  const element = elementRegistry.get(elementId);
+  if (!element) {
+    throw new Error(`Element "${elementId}" not found in the BPMN diagram`);
+  }
+  const templateId = getModdleString(element.businessObject, "modelerTemplate");
+  if (!templateId) {
+    throw new Error(
+      `Element "${elementId}" has no element template applied (no zeebe:modelerTemplate attribute). Use 'apply' to apply one first.`
+    );
+  }
+  const templateVersion = getModdleNumber(
+    element.businessObject,
+    "modelerTemplateVersion"
+  );
+  if (templateVersion === void 0) {
+    throw new Error(
+      `Element "${elementId}" has zeebe:modelerTemplate="${templateId}" but no recorded zeebe:modelerTemplateVersion. 'edit' requires a pinned version to resolve the exact template that was applied \u2014 use 'apply' with an explicit template reference instead.`
+    );
+  }
+  const template = await resolveOotbTemplate({
+    kind: "id",
+    id: templateId,
+    version: templateVersion
+  });
+  const extensionElements = getModdleElement(
+    element.businessObject,
+    "extensionElements"
+  );
+  const containers = findExtensionContainers(extensionElements);
+  const writesByChild = /* @__PURE__ */ new Map();
+  for (const arg of setArgs) {
+    const { bindingTypeFilter, name: name2, value } = parseSetArg(arg);
+    const matches = findPropertiesByBindingName(
+      template.properties,
+      name2,
+      bindingTypeFilter
+    );
+    let materialized = false;
+    for (const prop of matches) {
+      if (!prop.binding) continue;
+      const effectiveValue = maybePrependFeel(prop, value);
+      if (prop.choices) {
+        validateDropdownValue(prop, name2, effectiveValue);
+      }
+      const target = resolveBindingTarget(prop.binding, containers);
+      if (target) {
+        materialized = true;
+        let byProperty = writesByChild.get(target.child);
+        if (!byProperty) {
+          byProperty = /* @__PURE__ */ new Map();
+          writesByChild.set(target.child, byProperty);
+        }
+        byProperty.set(target.property, {
+          child: target.child,
+          property: target.property,
+          value: effectiveValue
+        });
+      }
+    }
+    if (!materialized) {
+      throw new Error(
+        `Property "${name2}" has no existing value on this element to edit (its condition may not be met, its binding type isn't supported by 'edit', or the template was never fully applied). Use 'apply --set ${name2}=...' to materialize it first.`
+      );
+    }
+  }
+  const writes = [];
+  for (const byProperty of writesByChild.values()) {
+    writes.push(...byProperty.values());
+  }
+  return { element, template, writes };
+}
+async function editSubcommand(args) {
+  const logger = c8ctl4.getLogger();
+  installStdoutEpipeHandler();
+  const parsed = parseArgs(args);
+  if (parsed.error) {
+    throw new Error(parsed.error);
+  }
+  const [elementId, bpmnFilePath] = parsed.positionals;
+  if (parsed.positionals.length > 2) {
+    throw new Error(
+      `Unexpected argument: ${parsed.positionals[2]}. Usage: c8ctl element-template edit <element-id> [<file.bpmn>] --set name=value`
+    );
+  }
+  if (!elementId) {
+    throw new Error(
+      "Missing element-id argument. Usage: c8ctl element-template edit <element-id> [<file.bpmn>] --set name=value"
+    );
+  }
+  if (parsed.setArgs.length === 0) {
+    throw new Error(
+      "edit requires at least one --set name=value (nothing to edit). Usage: c8ctl element-template edit <element-id> [<file.bpmn>] --set name=value"
+    );
+  }
+  if (parsed.inPlace && !bpmnFilePath) {
+    throw new Error("--in-place cannot be used with stdin input");
+  }
+  const input = await readBpmnInput(bpmnFilePath);
+  if (!input) {
+    throw new Error(
+      "No BPMN input provided. Pass a file path or pipe BPMN XML via stdin."
+    );
+  }
+  const vendorPath = resolveVendorBundle();
+  const vendor = require3(vendorPath);
+  const { Modeler, ZeebeModdleExtension, HeadlessTextRendererModule } = vendor;
+  const modeler = new Modeler({
+    additionalModules: [HeadlessTextRendererModule],
+    moddleExtensions: { zeebe: ZeebeModdleExtension }
+  });
+  let plan;
   try {
-    writeFileSync2(tmp, contents, "utf-8");
-    renameSync2(tmp, target);
+    await modeler.importXML(input.xml);
+    plan = await planEdit(modeler, elementId, parsed.setArgs);
   } catch (error3) {
-    try {
-      unlinkSync2(tmp);
-    } catch {
-    }
-    const code = isRecord(error3) && typeof error3.code === "string" ? error3.code : void 0;
-    if (code === "EXDEV") {
-      writeFileSync2(target, contents, "utf-8");
-      return;
+    const message = error3 instanceof Error ? error3.message : String(error3);
+    throw new Error(`Error editing element: ${message}`);
+  }
+  if (c8ctl4.dryRun) {
+    const info = {
+      dryRun: true,
+      command: "element-template edit",
+      template: {
+        id: plan.template.id,
+        name: plan.template.name,
+        version: plan.template.version
+      },
+      elementId,
+      source: input.source,
+      inPlace: parsed.inPlace && !!bpmnFilePath,
+      setOverrides: parsed.setArgs
+    };
+    if (c8ctl4.outputMode === "json") {
+      logger.json(info);
+    } else {
+      logger.output("Dry run \u2014 no changes applied.");
+      logger.output(
+        `  Template: ${info.template.name ?? info.template.id}${info.template.version != null ? ` v${info.template.version}` : ""}`
+      );
+      logger.output(`  Element:  ${elementId}`);
+      logger.output(`  Source:   ${input.source}`);
+      if (info.inPlace) {
+        logger.output(`  Mode:     in-place (would overwrite ${bpmnFilePath})`);
+      } else {
+        logger.output("  Mode:     stdout (would print transformed XML)");
+      }
+      logger.output(`  --set:    ${parsed.setArgs.join(", ")}`);
     }
-    throw error3;
+    return;
+  }
+  const modeling = modeler.get("modeling");
+  for (const write of plan.writes) {
+    modeling.updateModdleProperties(plan.element, write.child, {
+      [write.property]: write.value
+    });
   }
+  const result = await modeler.saveXML({ format: true });
+  const resultXml = result.xml;
+  if (parsed.inPlace && bpmnFilePath) {
+    atomicOverwriteFile(bpmnFilePath, resultXml);
+    logger.info(`Updated ${bpmnFilePath}`);
+    return;
+  }
+  process.stdout.write(resultXml);
 }
 
 // default-plugins/element-template/commands/get.ts
@@ -9426,7 +9615,7 @@ import { styleText as styleText2 } from "node:util";
 // default-plugins/element-template/commands/info.ts
 import { styleText } from "node:util";
 if (!globalThis.c8ctl) throw new Error("c8ctl runtime not initialised");
-var c8ctl4 = globalThis.c8ctl;
+var c8ctl5 = globalThis.c8ctl;
 function parseInspectArgs(args, usage, {
   allowPropertyNames,
   allowFilters
@@ -9554,7 +9743,7 @@ function formatKeyedCard({
   return lines;
 }
 async function infoSubcommand(args) {
-  const logger = c8ctl4.getLogger();
+  const logger = c8ctl5.getLogger();
   const usage = "Usage: c8ctl element-template info <template> [--engine-version <x.y.z>]";
   const { engineVersion, rest } = parseEngineVersionFlag(args, usage);
   const parsed = parseInspectArgs(rest, usage, {
@@ -9569,7 +9758,7 @@ async function infoSubcommand(args) {
       `Ignoring --engine-version ${engineVersion} because ${parsed.templateArg} pins a template version.`
     );
   }
-  if (c8ctl4.outputMode === "json") {
+  if (c8ctl5.outputMode === "json") {
     logger.json(buildTemplateSummary(template));
     return;
   }
@@ -9590,9 +9779,9 @@ async function infoSubcommand(args) {
 
 // default-plugins/element-template/commands/get-properties.ts
 if (!globalThis.c8ctl) throw new Error("c8ctl runtime not initialised");
-var c8ctl5 = globalThis.c8ctl;
+var c8ctl6 = globalThis.c8ctl;
 async function getPropertiesSubcommand(args) {
-  const logger = c8ctl5.getLogger();
+  const logger = c8ctl6.getLogger();
   const usage = "Usage: c8ctl element-template get-properties <template> [<name>...] [--group <id>...] [--detailed | -d] [--engine-version <x.y.z>]\n  Default: condensed list (name + description). --detailed shows full cards.\n  Names may include shell-style globs \u2014 quote to avoid shell expansion: 'auth*'";
   const { engineVersion, rest } = parseEngineVersionFlag(args, usage);
   const parsed = parseInspectArgs(rest, usage, {
@@ -9638,7 +9827,7 @@ async function getPropertiesSubcommand(args) {
     throw new Error(`No properties match ${what}.`);
   }
   const total = allDetails.length;
-  if (c8ctl5.outputMode === "json") {
+  if (c8ctl6.outputMode === "json") {
     const projector = parsed.detailed ? buildShowProperty : buildCondensedProperty;
     logger.json(
       buildJsonPayload(template, details, projector, total, sourceByDetail)
@@ -9861,9 +10050,9 @@ function formatBadgeValue(value) {
 // default-plugins/element-template/commands/search.ts
 import { styleText as styleText3 } from "node:util";
 if (!globalThis.c8ctl) throw new Error("c8ctl runtime not initialised");
-var c8ctl6 = globalThis.c8ctl;
+var c8ctl7 = globalThis.c8ctl;
 async function searchSubcommand(args) {
-  const logger = c8ctl6.getLogger();
+  const logger = c8ctl7.getLogger();
   const usage = "Usage: c8ctl element-template search <query> [--limit N] [--engine-version <x.y.z>]";
   const { engineVersion, rest } = parseEngineVersionFlag(args, usage);
   const DEFAULT_LIMIT = 20;
@@ -9908,7 +10097,7 @@ async function searchSubcommand(args) {
   const total = allMatches.length;
   const limited = allMatches.slice(0, limit);
   const truncated = total > limited.length;
-  if (c8ctl6.outputMode === "json") {
+  if (c8ctl7.outputMode === "json") {
     logger.json({
       query,
       count: limited.length,
@@ -9967,9 +10156,9 @@ async function searchSubcommand(args) {
 
 // default-plugins/element-template/commands/sync.ts
 if (!globalThis.c8ctl) throw new Error("c8ctl runtime not initialised");
-var c8ctl7 = globalThis.c8ctl;
+var c8ctl8 = globalThis.c8ctl;
 async function syncSubcommand(args) {
-  const logger = c8ctl7.getLogger();
+  const logger = c8ctl8.getLogger();
   let prune = false;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -9996,14 +10185,14 @@ async function syncSubcommand(args) {
     );
   }
   const summary = await syncTemplates({ logger, prune });
-  if (c8ctl7.outputMode === "json") {
+  if (c8ctl8.outputMode === "json") {
     logger.json(summary);
   }
 }
 
 // default-plugins/element-template/c8ctl-plugin.ts
 if (!globalThis.c8ctl) throw new Error("c8ctl runtime not initialised");
-var c8ctl8 = globalThis.c8ctl;
+var c8ctl9 = globalThis.c8ctl;
 function injectFlagsIntoArgs(args, flags) {
   const out = [...args];
   if (!flags) {
@@ -10034,6 +10223,7 @@ var subcommandHandlers = {
   info: infoSubcommand,
   "get-properties": getPropertiesSubcommand,
   apply: applySubcommand,
+  edit: editSubcommand,
   get: getSubcommand,
   sync: syncSubcommand
 };
@@ -10045,7 +10235,7 @@ async function elementTemplateHandler(args, flags) {
   const subcommand = reinjected[0];
   const subArgs = reinjected.slice(1);
   if (!subcommand || !isSubcommand(subcommand)) {
-    const logger = c8ctl8.getLogger();
+    const logger = c8ctl9.getLogger();
     const lead = subcommand ? `Unknown subcommand '${subcommand}'.` : "c8ctl element-template requires a subcommand.";
     const validSubcommands = Object.keys(subcommandHandlers);
     logger.info(`${lead} Available: ${validSubcommands.join(", ")}`);
@@ -10057,7 +10247,7 @@ async function elementTemplateHandler(args, flags) {
     await subcommandHandlers[subcommand](subArgs);
   } catch (error3) {
     const message = error3 instanceof Error ? error3.message : String(error3);
-    const logger = c8ctl8.getLogger();
+    const logger = c8ctl9.getLogger();
     logger.error(`Failed to element-template ${subcommand}: ${message}`);
     process.exitCode = 1;
   }
@@ -10068,7 +10258,7 @@ var metadata = {
   commands: {
     "element-template": {
       description: "Apply, inspect, and export Camunda element templates",
-      helpDescription: "Apply Camunda element templates to BPMN elements, inspect template metadata and properties, search the out-of-the-box template catalogue, export raw template JSON, and manage the local template cache.\n\n<template> is a local path, an https:// URL, or an OOTB template id (optionally @<version>).\n\napply --set name=value targets a property by binding name (run `get-properties` to discover names). Pass --set multiple times to set multiple properties. Prefix with a binding type (input | output | header | property | taskDefinition) when the same name is bound across multiple types \u2014 e.g. --set input:correlationKey=order-42.\n\nFEEL values: properties with feel=required always store a FEEL expression (prefixed with `=`). For those properties, c8ctl auto-prepends `=` when it is missing, so `--set key=orderId` writes `=orderId` to the BPMN \u2014 equivalent to `--set key==orderId`. Properties with feel=optional keep the value verbatim; you must supply the `=` prefix yourself when you want to write a FEEL expression for those. Three forms for feel=required properties:\n  --set key='=value'    canonical: single-quoted FEEL value (explicit =)\n  --set 'key==value'    compact: whole argument single-quoted (explicit =)\n  --set key=value       shorthand: = auto-prepended (feel=required only)\nLeading/trailing whitespace is stripped from values, and whitespace immediately after a FEEL `=` prefix is also stripped, so `--set 'key== value'` is equivalent to `--set 'key==value'`.",
+      helpDescription: "Apply Camunda element templates to BPMN elements, inspect template metadata and properties, search the out-of-the-box template catalogue, export raw template JSON, and manage the local template cache.\n\n<template> is a local path, an https:// URL, or an OOTB template id (optionally @<version>).\n\napply --set name=value targets a property by binding name (run `get-properties` to discover names). Pass --set multiple times to set multiple properties. Prefix with a binding type (input | output | header | property | taskDefinition) when the same name is bound across multiple types \u2014 e.g. --set input:correlationKey=order-42.\n\nedit --set name=value updates a property on an element that already has a template applied, without re-running template application \u2014 it never resets other template-owned content (including hand-customized extension values a template doesn't fully control) and doesn't need a <template> argument (it reads zeebe:modelerTemplate/-Version off the element). The tradeoff: edit can only change bindings that already have a value; a property whose gating condition was never met has nothing to edit \u2014 use apply --set to materialize it first.\n\nFEEL values: properties with feel=required always store a FEEL expression (prefixed with `=`). For those properties, c8ctl auto-prepends `=` when it is missing, so `--set key=orderId` writes `=orderId` to the BPMN \u2014 equivalent to `--set key==orderId`. Properties with feel=optional keep the value verbatim; you must supply the `=` prefix yourself when you want to write a FEEL expression for those. Three forms for feel=required properties:\n  --set key='=value'    canonical: single-quoted FEEL value (explicit =)\n  --set 'key==value'    compact: whole argument single-quoted (explicit =)\n  --set key=value       shorthand: = auto-prepended (feel=required only)\nLeading/trailing whitespace is stripped from values, and whitespace immediately after a FEEL `=` prefix is also stripped, so `--set 'key== value'` is equivalent to `--set 'key==value'`.",
       subcommands: [
         {
           name: "search",
@@ -10086,6 +10276,10 @@ var metadata = {
           name: "apply",
           description: "Apply a Camunda element template to a BPMN element"
         },
+        {
+          name: "edit",
+          description: "Update a property on an element that already has a template applied, without re-applying it"
+        },
         {
           name: "get",
           description: "Print the raw template JSON to stdout (pipe-friendly)"
@@ -10148,6 +10342,10 @@ var metadata = {
           command: "c8ctl element-template apply io.camunda.connectors.HttpJson.v2 Task_1 process.bpmn --set input:method=POST",
           description: "Qualify with <binding-type>:name=value when the same name is bound across multiple types"
         },
+        {
+          command: "c8ctl element-template edit Task_1 process.bpmn --set method=PUT",
+          description: "Update a single property on an already-templated element in place, without touching anything else the template governs"
+        },
         {
           command: "c8ctl element-template get io.camunda.connectors.HttpJson.v2 > template.json",
           description: "Print the raw template JSON to stdout (redirect to save a copy)"
@@ -10170,12 +10368,12 @@ var commands = {
       "in-place": {
         type: "boolean",
         short: "i",
-        description: "Modify the BPMN file in place [apply]"
+        description: "Modify the BPMN file in place [apply|edit]"
       },
       set: {
         type: "string",
         multiple: true,
-        description: "Set a property value: name=value (repeatable; binding name from get-properties; = auto-prepended for feel=required properties) [apply]"
+        description: "Set a property value: name=value (repeatable; binding name from get-properties; = auto-prepended for feel=required properties) [apply|edit]"
       },
       detailed: {
         type: "boolean",

package/dist/framework/command-registry.js

@@ -616,7 +616,7 @@ export const COMMAND_REGISTRY = {
             "tenants",
             "auth",
             "mapping-rules",
-            "wait-state",
+            "ws",
         ],
         // Verb-level `flags` holds only genuinely shared flags. Per-resource
         // flags live exclusively in `resourceFlags` so unknown-flag detection