@tenonhq/dovetail-servicenow 0.0.27 → 0.0.29

package/README.md

@@ -201,8 +201,62 @@ npx dove-sn edit-action --sys-id <action_type_sys_id> --scope <scope_sys_id> \
   --patch-script "grabHashData::grabRecipients"                                   # dry-run (diff)
 npx dove-sn edit-action --sys-id <id> --scope <scope> --set-script ./script.js \
   --merge-outputs ./output-var.json --apply --update-set <id>                     # persist + publish
+
+# Edit it STRUCTURALLY — several steps' scripts, step-level IO, pill wiring — in one publish
+npx dove-sn edit-action --sys-id <id> --scope <scope> --from-json ops.json             # dry-run
+npx dove-sn edit-action --sys-id <id> --scope <scope> --from-json ops.json \
+  --apply --update-set <id>                                                            # publish + verify
+```
+
+### Editing an action type's steps (`--from-json`)
+
+The flag form above patches the one auto-detected script. When you need to touch
+more than one step — or the step's own inputs and outputs — pass an ops file:
+
+```json
+{
+  "patchStepScripts": [
+    { "step": "Parse Response", "scriptFile": "./parse-response.js" },
+    { "step": "Handle Error", "patchScript": { "find": "gs.error", "replace": "gs.warn" } }
+  ],
+  "addStepOutputs": [
+    { "step": "Parse Response", "name": "isRetryable", "label": "Is Retryable", "type": "boolean" }
+  ],
+  "addStepInputs": [
+    {
+      "step": "Handle Error",
+      "name": "isRetryable",
+      "type": "boolean",
+      "pillFrom": { "step": "Parse Response", "output": "isRetryable" }
+    }
+  ]
+}
 ```
 
+- **`step`** is a step's `cid` **or** its label — an unknown ref fails with the list of steps that do exist.
+- **`scriptFile`** is sugar for `setScript`, resolved **relative to the ops file**, so scripts can live beside it.
+- **`addStepInputs[].pillFrom`** wires the input to another step's output. You never write the pill
+  yourself — the correct format is `{{step[<source_cid>].<output>}}`, and getting it wrong does not
+  fail the publish, it compiles a dead reference that reads `undefined` at runtime.
+- Ops are **order-independent**: an input may pill from an output added in the same call. Everything
+  lands in a **single** `/snapshot` POST.
+- Adding IO is **idempotent** — a name that is already present is skipped with a warning, not duplicated.
+
+Two behaviours worth knowing before you rely on this:
+
+**It refuses to guess an entry shape.** A new `extended_inputs` / `extended_outputs` entry is built by
+mirroring an existing sibling entry on the same step, because those entries carry more keys than the
+four you supply and some are wrapped as `{value: x}` inconsistently. If the step has *no* existing
+entry in that list, there is nothing to mirror and the command **errors out** rather than hand-author
+an object that would corrupt the action. Author one entry in the Designer first, then re-run.
+
+**It verifies the publish.** A `201` from `/snapshot` means the snapshot compiled — not that your edit
+landed as intended. With `--apply`, the steps are read back from the instance and compared against what
+was sent: script **content** (hashed, so a same-length-but-different script can't pass) and each IO
+entry's **name, type and value** — so an entry that landed with a mis-wired pill is caught, not just a
+missing one. A mismatch prints the diff and exits **2**. When every op was a no-op, there is nothing to
+read back and the round-trip is skipped.
+
 `copy-flow` calls the Designer's own `POST /processflow/flow/{id}/copy` — a
 complete, faithful clone created as an **inactive draft**. (Don't publish +
 activate a copy of a triggered production flow unless you intend it to fire.)
@@ -427,7 +481,9 @@ Claude Code and agents: `create_view`, `set_list_layout`, `set_form_layout`,
 existing record) and `create_record` (insert one record) — both update-set-captured
 and read-back-verified — `host_assets` (deploy a built dist/), plus the Flow Designer
 tools `flow_view` (read a flow/subflow's step graph), `action_view` (read an action
-type's model), `flow_publish` (compile a flow/subflow snapshot), `flow_copy`
+type's model), `action_edit` (structurally edit a published action type — per-step
+scripts, step-level inputs/outputs, data-pill wiring — dry-run by default, and the
+publish is read back and verified), `flow_publish` (compile a flow/subflow snapshot), `flow_copy`
 (copy a flow as an inactive draft), `flow_create` (create a NEW flow from scratch +
 publish, grafting a template), `flow_test` (validate or run a flow), and
 `flow_edit` (patch a flow), plus `invoke_rest` (invoke an arbitrary authenticated

package/dist/choices.d.ts

@@ -9,6 +9,7 @@
  */
 import type { ServiceNowClient } from "./client";
 import type { AddChoicesParams, AddChoicesResult } from "./types";
+export declare function encodeQueryValue(v: string): string;
 /**
  * Upsert choices for a field and (optionally) toggle sys_dictionary.choice.
  * Idempotent: re-running with the same inputs returns `action: "unchanged"`

package/dist/choices.js

@@ -9,6 +9,7 @@
  * so choices stay in the same application as the field.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeQueryValue = encodeQueryValue;
 exports.addChoicesToField = addChoicesToField;
 function encodeQueryValue(v) {
     // ServiceNow encoded-query values: commas/carets/equals are special. We
@@ -39,7 +40,10 @@ async function resolveScopeName(client, scopeSysId) {
 async function fetchDictionary(client, table, column) {
     var rows = await client.table.query("sys_dictionary", "name=" + encodeQueryValue(table) + "^element=" + encodeQueryValue(column), 1);
     if (rows.length === 0) {
-        throw new Error("sys_dictionary record not found for " + table + "." + column +
+        throw new Error("sys_dictionary record not found for " +
+            table +
+            "." +
+            column +
             " — verify the field exists and your user has read access.");
     }
     var row = rows[0];
@@ -53,7 +57,7 @@ async function fetchDictionary(client, table, column) {
         name: row.name,
         element: row.element,
         choice: String(row.choice || "0"),
-        sys_scope: scope || ""
+        sys_scope: scope || "",
     };
 }
 async function fetchUpdateSet(client, sysId) {
@@ -63,14 +67,16 @@ async function fetchUpdateSet(client, sysId) {
     }
     var row = rows[0];
     if (row.state && row.state !== "in progress" && row.state !== "in_progress") {
-        throw new Error("Update set " + row.name + " is in state '" + row.state +
+        throw new Error("Update set " +
+            row.name +
+            " is in state '" +
+            row.state +
             "' — only 'in progress' update sets can capture new changes.");
     }
     return row;
 }
 async function fetchExistingChoices(client, table, column) {
-    return client.table.query("sys_choice", "name=" + encodeQueryValue(table) +
-        "^element=" + encodeQueryValue(column), 1000);
+    return client.table.query("sys_choice", "name=" + encodeQueryValue(table) + "^element=" + encodeQueryValue(column), 1000);
 }
 function buildChoiceFields(table, column, choice, scope) {
     var fields = {
@@ -79,7 +85,7 @@ function buildChoiceFields(table, column, choice, scope) {
         value: choice.value,
         label: choice.label,
         language: choice.language || "en",
-        inactive: "false"
+        inactive: "false",
     };
     if (choice.sequence != null) {
         fields.sequence = String(choice.sequence);
@@ -114,7 +120,9 @@ async function addChoicesToField(client, params) {
     var scopeName = await resolveScopeName(client, dict.sys_scope);
     var targetChoiceType = params.choiceType === null
         ? Number(dict.choice)
-        : (params.choiceType != null ? params.choiceType : 3);
+        : params.choiceType != null
+            ? params.choiceType
+            : 3;
     var choiceWas = Number(dict.choice);
     var choiceNow = choiceWas;
     if (params.choiceType !== null && Number(dict.choice) !== targetChoiceType) {
@@ -122,7 +130,7 @@ async function addChoicesToField(client, params) {
             update_set_sys_id: params.updateSetSysId,
             table: "sys_dictionary",
             record_sys_id: dict.sys_id,
-            fields: { choice: String(targetChoiceType) }
+            fields: { choice: String(targetChoiceType) },
         });
         choiceNow = targetChoiceType;
     }
@@ -138,14 +146,19 @@ async function addChoicesToField(client, params) {
         var key = (choice.language || "en") + "::" + choice.value;
         var match = existingByValue[key];
         if (match && isUnchanged(match, choice)) {
-            results.push({ value: choice.value, label: choice.label, sysId: match.sys_id, action: "unchanged" });
+            results.push({
+                value: choice.value,
+                label: choice.label,
+                sysId: match.sys_id,
+                action: "unchanged",
+            });
             continue;
         }
         if (match) {
             var updFields = {
                 label: choice.label,
                 language: choice.language || "en",
-                inactive: "false"
+                inactive: "false",
             };
             if (choice.sequence != null) {
                 updFields.sequence = String(choice.sequence);
@@ -154,22 +167,27 @@ async function addChoicesToField(client, params) {
                 update_set_sys_id: params.updateSetSysId,
                 table: "sys_choice",
                 record_sys_id: match.sys_id,
-                fields: updFields
+                fields: updFields,
+            });
+            results.push({
+                value: choice.value,
+                label: choice.label,
+                sysId: match.sys_id,
+                action: "updated",
             });
-            results.push({ value: choice.value, label: choice.label, sysId: match.sys_id, action: "updated" });
             continue;
         }
         var created = await client.claude.createRecord({
             table: "sys_choice",
             fields: buildChoiceFields(params.table, params.column, choice, dict.sys_scope),
             scope: scopeName,
-            update_set_sys_id: params.updateSetSysId
+            update_set_sys_id: params.updateSetSysId,
         });
         results.push({
             value: choice.value,
             label: choice.label,
             sysId: created.sys_id,
-            action: "created"
+            action: "created",
         });
     }
     return {
@@ -177,9 +195,9 @@ async function addChoicesToField(client, params) {
             sysId: dict.sys_id,
             scope: dict.sys_scope,
             choiceWas: choiceWas,
-            choiceNow: choiceNow
+            choiceNow: choiceNow,
         },
         updateSet: { sysId: updateSet.sys_id, name: updateSet.name },
-        choices: results
+        choices: results,
     };
 }

package/dist/cli.js

@@ -87,24 +87,30 @@ const flowDesigner_formatter_2 = require("./flowDesigner-formatter");
 function parseArgs(argv) {
     var command = argv[0] || "";
     var flags = {};
+    var bare = {};
     for (var i = 1; i < argv.length; i += 1) {
         var arg = argv[i];
         if (arg.indexOf("--") !== 0)
             continue;
         var key = arg.slice(2);
         var value = "true";
+        var isBare = true;
         var eq = key.indexOf("=");
         if (eq !== -1) {
             value = key.slice(eq + 1);
             key = key.slice(0, eq);
+            isBare = false;
         }
         else if (i + 1 < argv.length && argv[i + 1].indexOf("--") !== 0) {
             value = argv[i + 1];
             i += 1;
+            isBare = false;
         }
         flags[key] = value;
+        if (isBare)
+            bare[key] = true;
     }
-    return { command: command, flags: flags };
+    return { command: command, flags: flags, bare: bare };
 }
 function parseChoicesInline(input) {
     return input.split(",").map(function (pair) {
@@ -666,17 +672,54 @@ async function runEditFlow(flags) {
  * dove-sn edit-action:
  *   --sys-id <sys_id>                  Required. sys_hub_action_type_definition sys_id.
  *   --scope <sys_id>                   Required. sysparm_transaction_scope (app scope sys_id).
- *   --patch-script "<find>::<replace>" Optional. Find/replace in the script step value.
- *   --set-script <path>                Optional. Replace the script step value from a file.
+ *   --from-json <path>                 Optional. JSON EditActionTypeOps — the full surface, incl.
+ *                                      per-step ops: patchStepScripts / addStepOutputs / addStepInputs.
+ *   --patch-script "<find>::<replace>" Optional. Find/replace in the auto-detected script step value.
+ *   --set-script <path>                Optional. Replace the auto-detected script step value from a file.
  *   --merge-outputs <path>             Optional. JSON file: an output-variable object/array to merge by name.
  *   --script-input <name>              Optional. Input name holding the script (default: auto-detect).
  *   --update-set <sys_id>              Optional. Capture the republish into this update set.
  *   --apply                            Optional. Republish (POST /snapshot). Omit for dry-run.
  *   --json                             Optional. Emit the structured EditActionTypeResult.
  *
- * Edits a published Custom Action Type's script and/or output variables and
- * republishes through the snapshot POST. Dry-run (read-only) by default; --apply writes.
+ * Edits a published Custom Action Type and republishes through the snapshot POST.
+ * Dry-run (read-only) by default; --apply writes.
+ *
+ * The flag form handles the single-script case. For anything structural — patching
+ * several steps' scripts, adding a step-level output, adding a step-level input
+ * pill-wired to another step's output — use --from-json:
+ *
+ *   {
+ *     "patchStepScripts": [{ "step": "Parse Response", "scriptFile": "./parse.js" }],
+ *     "addStepOutputs":   [{ "step": "Parse Response", "name": "isRetryable", "type": "boolean" }],
+ *     "addStepInputs":    [{ "step": "Handle Error", "name": "isRetryable", "type": "boolean",
+ *                            "pillFrom": { "step": "Parse Response", "output": "isRetryable" } }]
+ *   }
+ *
+ * `step` is a step cid or label. `scriptFile` is sugar for `setScript` and is
+ * resolved RELATIVE TO THE OPS FILE, so an ops file can sit next to its scripts.
  */
+/** Resolve `scriptFile` sugar in patchStepScripts, relative to the ops file's own dir. */
+function resolveScriptFiles(ops, opsPath) {
+    var stepScripts = ops.patchStepScripts;
+    if (!Array.isArray(stepScripts)) {
+        return;
+    }
+    var opsDir = path.dirname(path.resolve(opsPath));
+    for (var i = 0; i < stepScripts.length; i += 1) {
+        var op = stepScripts[i];
+        if (!op || typeof op !== "object" || typeof op.scriptFile !== "string") {
+            continue;
+        }
+        if (typeof op.setScript === "string") {
+            throw new Error("edit-action: step '" +
+                String(op.step) +
+                "' sets both scriptFile and setScript — pick one.");
+        }
+        op.setScript = fs.readFileSync(path.resolve(opsDir, op.scriptFile), "utf8");
+        delete op.scriptFile;
+    }
+}
 async function runEditAction(flags) {
     var sysId = flags["sys-id"] || flags.sysId;
     var scope = flags.scope || flags.scopeSysId;
@@ -685,6 +728,14 @@ async function runEditAction(flags) {
         return 1;
     }
     var ops = {};
+    if (flags["from-json"]) {
+        ops = JSON.parse(fs.readFileSync(flags["from-json"], "utf8"));
+        if (!ops || typeof ops !== "object" || Array.isArray(ops)) {
+            process.stderr.write("edit-action: --from-json must contain an EditActionTypeOps object\n");
+            return 1;
+        }
+        resolveScriptFiles(ops, flags["from-json"]);
+    }
     if (flags["patch-script"]) {
         var parts = String(flags["patch-script"]).split("::");
         if (parts.length !== 2) {
@@ -730,6 +781,51 @@ async function runEditAction(flags) {
     for (var wi = 0; wi < result.warnings.length; wi += 1) {
         process.stdout.write("  ! " + result.warnings[wi] + "\n");
     }
+    // Per-step before/after — the dry-run's whole job is to make this inspectable.
+    if (result.stepsBefore && result.stepsAfter) {
+        process.stdout.write("\n--- steps (before -> after) ---\n");
+        for (var si = 0; si < result.stepsAfter.length; si += 1) {
+            var after = result.stepsAfter[si];
+            var before = result.stepsBefore[si];
+            var io = function (label, list) {
+                if (list.length === 0) {
+                    return "";
+                }
+                var rendered = list
+                    .map(function (e) {
+                    return e.name + (e.value ? "=" + e.value : "");
+                })
+                    .join(", ");
+                return "\n      " + label + ": " + rendered;
+            };
+            process.stdout.write("  " +
+                after.label +
+                " (" +
+                after.cid +
+                ")\n" +
+                "      script: " +
+                String(before ? before.scriptChars : "?") +
+                " -> " +
+                String(after.scriptChars) +
+                " chars" +
+                io("in ", after.extendedInputs) +
+                io("out", after.extendedOutputs) +
+                "\n");
+        }
+    }
+    if (result.verified) {
+        process.stdout.write("\n--- verify (read back from the instance) ---\n");
+        process.stdout.write("  " + (result.verified.ok ? "OK" : "FAILED") + "\n");
+        for (var vi = 0; vi < result.verified.notes.length; vi += 1) {
+            process.stdout.write("  " +
+                (result.verified.ok ? "+ " : "! ") +
+                result.verified.notes[vi] +
+                "\n");
+        }
+        if (!result.verified.ok) {
+            return 2;
+        }
+    }
     if (result.status === "preview" &&
         result.scriptAfter !== undefined &&
         result.scriptAfter !== result.scriptBefore) {
@@ -786,6 +882,17 @@ function printHelp() {
         "                      [--name <element>] [--max-length <n>] [--reference <table>]\n" +
         "                      [--mandatory] [--default <v>] [--scope <s>] [--dry-run] [--json])\n" +
         "                     --update-set is REQUIRED on the live path (not for --dry-run).\n" +
+        "  set-column         Update an EXISTING column's SCHEMA (label/mandatory/default/read-only/max-length),\n" +
+        "                     into an update set, then verify against the instance\n" +
+        "                     (--table <t> --column <c> --update-set <sys_id>\n" +
+        "                      [--label <l>] [--mandatory true|false] [--default <v>]\n" +
+        "                      [--read-only true|false] [--max-length <n>]\n" +
+        "                      [--dry-run] [--json])\n" +
+        "                     A max-length SHRINK is REFUSED while rows hold longer values —\n" +
+        "                     ServiceNow silently ignores such a shrink (200 OK, no change).\n" +
+        "                     Shorten or clear those values first, then re-run.\n" +
+        "                     --element / --internal-type are REFUSED with an explanation:\n" +
+        "                     ServiceNow silently ignores both on an existing column.\n" +
         "  invoke-rest        Invoke an arbitrary authenticated REST operation (Scripted REST incl.)\n" +
         "                     DRY-RUN BY DEFAULT — nothing is sent without --confirm\n" +
         "                     (--method <GET|POST|PUT|DELETE> --path /api/<scope>/<service>/<resource>\n" +
@@ -801,6 +908,12 @@ function printHelp() {
         "                      [--update-set <sys_id>] [--max-bytes <n>] [--allow-oversize] [--dry-run] [--json])\n" +
         "  test-flow          Validate (default) or run a flow/subflow\n" +
         "                     (--sys-id <sys_id> [--execute --confirm] [--inputs <json>] [--json])\n" +
+        "  edit-action        Patch a published Custom Action Type and republish (snapshot)\n" +
+        "                     (--sys-id <sys_id> --scope <sys_id>\n" +
+        "                      --from-json <ops.json>  ops: patchStepScripts / addStepOutputs / addStepInputs\n" +
+        "                                              (per-step scripts + step IO + data-pill wiring)\n" +
+        '                      | --patch-script "<find>::<replace>" | --set-script <path> | --merge-outputs <path>\n' +
+        "                      [--script-input <name>] [--update-set <sys_id>] [--apply] [--json])\n" +
         "  edit-flow          Patch a flow/subflow (rename, description, step inputs)\n" +
         "                     (--sys-id <sys_id> --from-json <ops.json> [--apply] [--update-set <sys_id>] [--scope <sys_id>] [--json])\n" +
         "  mcp                Run the MCP stdio server (--smoke lists tools and exits)\n" +
@@ -991,6 +1104,111 @@ async function runAddColumn(flags) {
         return 2;
     return 0;
 }
+/** Parse a CLI boolean flag. Bare `--mandatory` means true; `--mandatory false` means
+ *  false. Anything else is rejected rather than quietly coerced to `true`. */
+function parseBoolFlag(name, raw) {
+    if (raw === "true")
+        return true;
+    if (raw === "false")
+        return false;
+    throw new Error("set-column: --" + name + " must be true or false (got '" + raw + "').");
+}
+/**
+ * dove-sn set-column:
+ *   --table x_cadso_journey --column description --update-set <sys_id>
+ *   [--label "Description"] [--mandatory true|false] [--default <v>]
+ *   [--read-only true|false] [--max-length 4000] [--dry-run] [--json]
+ *
+ * Updates an EXISTING column's schema. `internal_type` and a rename are refused —
+ * ServiceNow silently ignores both on an existing column. To CREATE one, use add-column;
+ * to set a RECORD's value, use set-field.
+ */
+async function runSetColumn(flags, bare) {
+    // A string flag whose value was forgotten arrives as the literal "true" — `--label`
+    // with nothing after it would rename the column to "true". Booleans legitimately do
+    // that, strings never do, so refuse rather than silently write nonsense.
+    var stringFlags = ["label", "default", "table", "column", "update-set"];
+    for (var f = 0; f < stringFlags.length; f += 1) {
+        if (bare[stringFlags[f]]) {
+            process.stderr.write("set-column: --" +
+                stringFlags[f] +
+                " needs a value (it was given none).\n");
+            return 1;
+        }
+    }
+    var table = flags.table;
+    var column = flags.column;
+    if (!table || !column) {
+        process.stderr.write("set-column: --table and --column are required " +
+            "(--update-set is required too, unless --dry-run)\n");
+        return 1;
+    }
+    var attributes = {};
+    // Accepted so that setColumn can REFUSE them by name with the reason. Dropping them
+    // silently would leave someone who asked for a rename believing it happened.
+    if (flags.element !== undefined)
+        attributes.element = flags.element;
+    if (flags["internal-type"] !== undefined) {
+        attributes.internalType = flags["internal-type"];
+    }
+    if (flags.label !== undefined)
+        attributes.label = flags.label;
+    if (flags.default !== undefined)
+        attributes.default = flags.default;
+    if (flags.mandatory !== undefined) {
+        attributes.mandatory = parseBoolFlag("mandatory", flags.mandatory);
+    }
+    if (flags["read-only"] !== undefined) {
+        attributes.readOnly = parseBoolFlag("read-only", flags["read-only"]);
+    }
+    if (flags["max-length"] !== undefined) {
+        var len = Number(flags["max-length"]);
+        // sys_dictionary.max_length is an integer; the MCP schema enforces int() too.
+        if (!Number.isInteger(len) || len < 1) {
+            process.stderr.write("set-column: --max-length must be a positive integer\n");
+            return 1;
+        }
+        attributes.maxLength = len;
+    }
+    var params = {
+        client: (0, client_1.createClient)({}),
+        table: table,
+        column: column,
+        attributes: attributes,
+    };
+    // Accept the same alias pair as the other verbs (create-view, set-list-layout, …).
+    var setColumnUs = flags["update-set"] || flags.updateSetSysId;
+    if (setColumnUs)
+        params.updateSetSysId = setColumnUs;
+    if (flags["dry-run"] === "true")
+        params.dryRun = true;
+    var result = await (0, table_1.setColumn)(params);
+    if (flags.json === "true") {
+        process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    }
+    else {
+        process.stdout.write("[" +
+            result.status +
+            "] " +
+            result.table +
+            "." +
+            result.column +
+            (result.verified && result.status === "applied" ? " — verified" : "") +
+            (result.status === "applied" && !result.capturedInUpdateSet
+                ? " — NOT CAPTURED"
+                : "") +
+            "\n" +
+            result.note +
+            "\n");
+    }
+    // 2 = the write landed but the instance does not reflect it (or it was not captured),
+    // which must not read as success to a script.
+    if (result.status === "failed")
+        return 2;
+    if (result.status === "applied" && !result.capturedInUpdateSet)
+        return 2;
+    return 0;
+}
 /** Parse inline `--fields "k=v, k2=v2"` into a field map. */
 function parseFieldsInline(input) {
     var out = {};
@@ -1292,6 +1510,9 @@ async function main() {
     if (parsed.command === "add-column") {
         return await runAddColumn(parsed.flags);
     }
+    if (parsed.command === "set-column") {
+        return await runSetColumn(parsed.flags, parsed.bare);
+    }
     if (parsed.command === "set-field") {
         return await runSetField(parsed.flags);
     }

package/dist/flowDesigner/editActionType.d.ts

@@ -23,6 +23,7 @@
  * Full write-up: docs/servicenow-flow-designer-headless-authoring.md.
  */
 import type { ServiceNowClient } from "../client";
+import type { AddStepInputOp, AddStepOutputOp, PatchStepScriptOp, StepSummary, VerifyStepsResult } from "./stepOps";
 export interface EditActionTypeOps {
     /** Replace every occurrence of `find` with `replace` inside the script step value. */
     patchScript?: {
@@ -31,6 +32,25 @@ export interface EditActionTypeOps {
     };
     /** Replace the script step value outright (wins over patchScript). */
     setScript?: string;
+    /**
+     * Per-step script edits, addressing each step by `cid` or `label`. Use this
+     * instead of patchScript/setScript when the action has more than one scripted
+     * step, or when you need to target a specific one rather than the auto-detected
+     * first match.
+     */
+    patchStepScripts?: Array<PatchStepScriptOp>;
+    /**
+     * Step-level outputs (`extended_outputs`) to add — the values one step exposes
+     * to the steps after it. Idempotent: an output whose name is already present is
+     * skipped, not duplicated.
+     */
+    addStepOutputs?: Array<AddStepOutputOp>;
+    /**
+     * Step-level inputs (`extended_inputs`) to add, each wired by data pill to
+     * another step's output via `pillFrom: { step, output }`. Outputs added in the
+     * same call are visible to these — it all lands in one snapshot.
+     */
+    addStepInputs?: Array<AddStepInputOp>;
     /**
      * Output-variable definition objects to merge into `model.outputs`, matched by
      * `name` (replaced in place, else appended). Supply the modeled output JSON —
@@ -63,6 +83,15 @@ export interface EditActionTypeResult {
     scriptBefore?: string;
     scriptAfter?: string;
     outputsMerged: Array<string>;
+    /** Per-step scripts + step-level IO, as read (before) and as sent (after). */
+    stepsBefore?: Array<StepSummary>;
+    stepsAfter?: Array<StepSummary>;
+    /**
+     * Post-publish read-back of /step_instances for the steps we touched. A 201 from
+     * /snapshot means "compiled", not "your edit landed" — only set when applied and
+     * step ops were supplied.
+     */
+    verified?: VerifyStepsResult;
     /** HTTP status of the snapshot POST (201 on success); only set when applied. */
     httpStatus?: number;
     snapshotSysId?: string;