@tenonhq/dovetail-servicenow 0.0.43 → 0.0.45

package/dist/flowDesigner/cloneActionType.d.ts

@@ -14,6 +14,21 @@
  *        ├─ sys_hub_step_ext_input   (model_id → step)
  *        └─ sys_hub_step_ext_output  (model_id → step)
  *
+ * Plus two stores the action's IO depends on that are NOT FK children
+ * (verified live on tenonworkstudio 2026-09-30):
+ *
+ *   sys_element_mapping   output → step-output wiring, one row per mapped output
+ *                         (incl. __action_status__ / __dont_treat_as_error__):
+ *                         id = action sys_id, table = var__m_sys_hub_action_output_<action>,
+ *                         field = output element, value = the pill. Without these a
+ *                         clone publishes with every output unmapped (runs, returns empty).
+ *   sys_documentation     IO labels: name = var__m_sys_hub_action_{input,output}_<action>,
+ *                         element, label, language. Without these Flow Designer shows the
+ *                         element name as the label.
+ *
+ * Action IO rows are var_dictionary rows whose `name` IS their var__m table, so
+ * the clone retargets `name` onto the new action's var__m table too.
+ *
  * Publish reuses the proven snapshot path (publishActionType): the SOURCE
  * action's step graph is read from /step_instances, each step's `action` and
  * `sys_id` are remapped onto the clone (old→new sys_id map), optional StepOps
@@ -77,6 +92,12 @@ export interface CloneActionTypePlan {
     sourceScopeSysId: string;
     /** Old → new sys_id for every cloned step instance. */
     stepIdMap: Record<string, string>;
+    /**
+     * The sys_documentation (label) ops inside `ops`. They are UPSERTED after the
+     * graph is written (the dictionary insert may already have created the row),
+     * not run through executeWritePlan.
+     */
+    labelOpIds: Array<string>;
 }
 export interface CloneActionTypeStepReport {
     /** Step summary of the cloned graph before stepOps. */
@@ -99,6 +120,10 @@ export interface CloneActionTypeResult {
     verify?: VerifyStepsResult;
     steps?: CloneActionTypeStepReport;
 }
+/** var_dictionary table name for a model's variables: var__m_<table>_<model sys_id>. */
+export declare function varTableName(table: string, modelSysId: string): string;
+/** The encoded query for an action's output → step-output mappings. */
+export declare function outputMappingQuery(actionSysId: string): string;
 /** Slug for internal_name: lowercase, runs of non-alphanumerics → "_", trimmed of "_". */
 export declare function slugInternalName(name: string): string;
 /**
@@ -117,3 +142,18 @@ export declare function resolveScope(client: ServiceNowClient, ref: string): Pro
  */
 export declare function remapClonedSteps(steps: Array<StepRecord>, newParentSysId: string, stepIdMap: Record<string, string>, idMap: Record<string, string>): Array<StepRecord>;
 export declare function cloneActionType(opts: CloneActionTypeParams): Promise<CloneActionTypeResult>;
+/**
+ * Set `name` on a cloned var_dictionary row (action IO / step ext IO) to the
+ * clone's var__m table — but only when it named the SOURCE model's var__m table
+ * exactly; anything else is left as it was.
+ */
+export declare function retargetVarName(fields: Record<string, unknown>, table: string, oldModelSysId: string, newModelSysId: string): void;
+/**
+ * Compare the source action's output mappings with the clone's, by `field`.
+ * A source field absent on the clone fails; a differing value is noted but does
+ * not fail (publish may legitimately normalise a pill).
+ */
+export declare function verifyOutputMappings(sourceRows: Array<Record<string, unknown>>, cloneRows: Array<Record<string, unknown>>): {
+    ok: boolean;
+    notes: Array<string>;
+};

package/dist/flowDesigner/cloneActionType.js

@@ -15,6 +15,21 @@
  *        ├─ sys_hub_step_ext_input   (model_id → step)
  *        └─ sys_hub_step_ext_output  (model_id → step)
  *
+ * Plus two stores the action's IO depends on that are NOT FK children
+ * (verified live on tenonworkstudio 2026-09-30):
+ *
+ *   sys_element_mapping   output → step-output wiring, one row per mapped output
+ *                         (incl. __action_status__ / __dont_treat_as_error__):
+ *                         id = action sys_id, table = var__m_sys_hub_action_output_<action>,
+ *                         field = output element, value = the pill. Without these a
+ *                         clone publishes with every output unmapped (runs, returns empty).
+ *   sys_documentation     IO labels: name = var__m_sys_hub_action_{input,output}_<action>,
+ *                         element, label, language. Without these Flow Designer shows the
+ *                         element name as the label.
+ *
+ * Action IO rows are var_dictionary rows whose `name` IS their var__m table, so
+ * the clone retargets `name` onto the new action's var__m table too.
+ *
  * Publish reuses the proven snapshot path (publishActionType): the SOURCE
  * action's step graph is read from /step_instances, each step's `action` and
  * `sys_id` are remapped onto the clone (old→new sys_id map), optional StepOps
@@ -32,10 +47,14 @@
  * docs/servicenow-flow-designer-headless-authoring.md.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.varTableName = varTableName;
+exports.outputMappingQuery = outputMappingQuery;
 exports.slugInternalName = slugInternalName;
 exports.resolveScope = resolveScope;
 exports.remapClonedSteps = remapClonedSteps;
 exports.cloneActionType = cloneActionType;
+exports.retargetVarName = retargetVarName;
+exports.verifyOutputMappings = verifyOutputMappings;
 const shape_1 = require("./shape");
 const writeOrder_1 = require("./writeOrder");
 const actionTypeApi_1 = require("./actionTypeApi");
@@ -47,6 +66,16 @@ var OUTPUT_TABLE = "sys_hub_action_output";
 var STEP_TABLE = "sys_hub_step_instance";
 var EXT_INPUT_TABLE = "sys_hub_step_ext_input";
 var EXT_OUTPUT_TABLE = "sys_hub_step_ext_output";
+var MAPPING_TABLE = "sys_element_mapping";
+var LABEL_TABLE = "sys_documentation";
+/** var_dictionary table name for a model's variables: var__m_<table>_<model sys_id>. */
+function varTableName(table, modelSysId) {
+    return "var__m_" + table + "_" + modelSysId;
+}
+/** The encoded query for an action's output → step-output mappings. */
+function outputMappingQuery(actionSysId) {
+    return "id=" + actionSysId + "^tableSTARTSWITH" + "var__m_" + OUTPUT_TABLE + "_";
+}
 /** Rows per child query. A full page means the read may be truncated — refuse rather than half-clone. */
 var CHILD_LIMIT = 1000;
 /**
@@ -307,6 +336,10 @@ async function cloneActionType(opts) {
             scope: scope.name,
         },
     ];
+    // element → plan op id, per IO table, so label/mapping ops can depend on their row.
+    var ioOpByElement = {};
+    ioOpByElement[INPUT_TABLE] = {};
+    ioOpByElement[OUTPUT_TABLE] = {};
     var pushModelChildren = function (table, prefix, rows) {
         for (var r = 0; r < rows.length; r++) {
             var src = flattenRow(rows[r]);
@@ -314,6 +347,11 @@ async function cloneActionType(opts) {
             idMap[String(src.sys_id || "")] = childSysId;
             var fields = cloneFields(src, scope.sysId, childSysId);
             fields.model_id = newParentSysId;
+            retargetVarName(fields, table, opts.sourceSysId, newParentSysId);
+            var element = String(src.element || "");
+            if (element) {
+                ioOpByElement[table][element] = prefix + ":" + r;
+            }
             ops.push({
                 id: prefix + ":" + r,
                 logicalName: table + ":" + String(src.element || src.name || src.sys_id),
@@ -356,6 +394,7 @@ async function cloneActionType(opts) {
                 idMap[String(srcExt.sys_id || "")] = newExtSysId;
                 var extFields = cloneFields(srcExt, scope.sysId, newExtSysId);
                 extFields.model_id = newStepSysId;
+                retargetVarName(extFields, extSpecs[x].table, oldStepSysId, newStepSysId);
                 ops.push({
                     id: stepOpId + ":" + extSpecs[x].prefix + ":" + e,
                     logicalName: extSpecs[x].table + ":" + String(srcExt.element || srcExt.name || srcExt.sys_id),
@@ -367,13 +406,78 @@ async function cloneActionType(opts) {
             }
         }
     }
+    // 3b. Output → step-output wiring (sys_element_mapping). Step cids survive the
+    // clone, so field and value (the pill) carry over unchanged.
+    var newOutputVarTable = varTableName(OUTPUT_TABLE, newParentSysId);
+    var sourceMappings = await queryChildren(client, MAPPING_TABLE, outputMappingQuery(opts.sourceSysId));
+    for (var mi = 0; mi < sourceMappings.length; mi++) {
+        var srcMap = flattenRow(sourceMappings[mi]);
+        var mapField = String(srcMap.field || "");
+        var mapFields = cloneFields(srcMap, scope.sysId, (0, shape_1.generateSysId)());
+        mapFields.id = newParentSysId;
+        mapFields.table = newOutputVarTable;
+        // After the parent and its outputs (the matching output first), so a mapping never precedes the row it wires.
+        var mapDeps = ["parent"];
+        if (mapField && Object.prototype.hasOwnProperty.call(ioOpByElement[OUTPUT_TABLE], mapField)) {
+            mapDeps.push(ioOpByElement[OUTPUT_TABLE][mapField]);
+        }
+        var outputOpIds = Object.keys(ioOpByElement[OUTPUT_TABLE]).map(function (el) { return ioOpByElement[OUTPUT_TABLE][el]; });
+        for (var oi = 0; oi < outputOpIds.length; oi++) {
+            if (mapDeps.indexOf(outputOpIds[oi]) === -1) {
+                mapDeps.push(outputOpIds[oi]);
+            }
+        }
+        ops.push({
+            id: "mapping:" + mi,
+            logicalName: MAPPING_TABLE + ":" + (mapField || String(srcMap.sys_id || mi)),
+            table: MAPPING_TABLE,
+            fields: mapFields,
+            dependsOn: mapDeps,
+            scope: scope.name,
+        });
+    }
+    // 3c. IO labels (sys_documentation keyed on the var__m table), retargeted.
+    var labelOps = [];
+    var labelSpecs = [
+        { table: INPUT_TABLE, prefix: "label:input" },
+        { table: OUTPUT_TABLE, prefix: "label:output" },
+    ];
+    for (var li = 0; li < labelSpecs.length; li++) {
+        var spec = labelSpecs[li];
+        var srcVarTable = varTableName(spec.table, opts.sourceSysId);
+        var newVarTable = varTableName(spec.table, newParentSysId);
+        var labelRows = await queryChildren(client, LABEL_TABLE, "name=" + srcVarTable);
+        for (var lr = 0; lr < labelRows.length; lr++) {
+            var srcLabel = flattenRow(labelRows[lr]);
+            var labelElement = String(srcLabel.element || "");
+            if (!labelElement) {
+                continue;
+            }
+            var labelFields = cloneFields(srcLabel, scope.sysId, (0, shape_1.generateSysId)());
+            labelFields.name = newVarTable;
+            var labelDeps = ["parent"];
+            if (Object.prototype.hasOwnProperty.call(ioOpByElement[spec.table], labelElement)) {
+                labelDeps.push(ioOpByElement[spec.table][labelElement]);
+            }
+            labelOps.push({
+                id: spec.prefix + ":" + lr,
+                logicalName: LABEL_TABLE + ":" + newVarTable + "." + labelElement,
+                table: LABEL_TABLE,
+                fields: labelFields,
+                dependsOn: labelDeps,
+                scope: scope.name,
+            });
+        }
+    }
+    var allOps = ops.concat(labelOps);
     var plan = {
-        ops: ops,
-        counts: countByTable(ops),
-        total: ops.length,
+        ops: allOps,
+        counts: countByTable(allOps),
+        total: allOps.length,
         scope: scope,
         sourceScopeSysId: sourceScopeSysId,
         stepIdMap: stepIdMap,
+        labelOpIds: labelOps.map(function (o) { return o.id; }),
     };
     // 4. The publishable step graph: the SOURCE's /step_instances, remapped.
     var sourceSteps = await (0, actionTypeApi_1.fetchActionSteps)(client, opts.sourceSysId, sourceScopeSysId);
@@ -412,6 +516,11 @@ async function cloneActionType(opts) {
     // 5. Write the graph, pinned to the update set.
     var updateSetSysId = opts.updateSetSysId;
     var written = await (0, writeOrder_1.executeWritePlan)(client, ops, updateSetSysId);
+    // Labels last: the IO dictionary inserts above may already have created a
+    // sys_documentation row for the new var__m table, so upsert rather than duplicate.
+    for (var lw = 0; lw < labelOps.length; lw++) {
+        written.push(await upsertLabel(client, labelOps[lw], updateSetSysId));
+    }
     var result = {
         sysId: newParentSysId,
         internalName: internalName,
@@ -440,16 +549,129 @@ async function cloneActionType(opts) {
     }
     // 7. Verify — a 201 means "compiled", not "landed as sent". Read the clone's steps back.
     var fresh = await (0, actionTypeApi_1.fetchActionSteps)(client, newParentSysId, scope.sysId);
+    var verify;
     if (fresh.length === 0) {
-        result.verify = { ok: false, notes: ["read-back returned no steps — could not verify the publish"] };
+        verify = { ok: false, notes: ["read-back returned no steps — could not verify the publish"] };
     }
     else {
         var expected = stepReport.after;
-        result.verify = (0, stepOps_1.verifySteps)(expected, (0, stepOps_1.summarizeSteps)(fresh), allCids(finalSteps));
+        verify = (0, stepOps_1.verifySteps)(expected, (0, stepOps_1.summarizeSteps)(fresh), allCids(finalSteps));
         if (fresh.length !== finalSteps.length) {
-            result.verify.ok = false;
-            result.verify.notes.push("step count on the instance is " + fresh.length + ", expected " + finalSteps.length);
+            verify.ok = false;
+            verify.notes.push("step count on the instance is " + fresh.length + ", expected " + finalSteps.length);
         }
     }
+    // Output mappings: every source mapping must exist on the clone, or its outputs come back empty.
+    var cloneMappings = await queryChildren(client, MAPPING_TABLE, outputMappingQuery(newParentSysId));
+    var mappingCheck = verifyOutputMappings(sourceMappings, cloneMappings);
+    if (!mappingCheck.ok) {
+        verify.ok = false;
+    }
+    for (var vn = 0; vn < mappingCheck.notes.length; vn++) {
+        verify.notes.push(mappingCheck.notes[vn]);
+    }
+    result.verify = verify;
     return result;
 }
+/**
+ * Set `name` on a cloned var_dictionary row (action IO / step ext IO) to the
+ * clone's var__m table — but only when it named the SOURCE model's var__m table
+ * exactly; anything else is left as it was.
+ */
+function retargetVarName(fields, table, oldModelSysId, newModelSysId) {
+    if (!Object.prototype.hasOwnProperty.call(fields, "name")) {
+        return;
+    }
+    if (String(fields.name) === varTableName(table, oldModelSysId)) {
+        fields.name = varTableName(table, newModelSysId);
+    }
+}
+/**
+ * Compare the source action's output mappings with the clone's, by `field`.
+ * A source field absent on the clone fails; a differing value is noted but does
+ * not fail (publish may legitimately normalise a pill).
+ */
+function verifyOutputMappings(sourceRows, cloneRows) {
+    var cloneByField = {};
+    for (var c = 0; c < cloneRows.length; c++) {
+        var cr = flattenRow(cloneRows[c]);
+        var cf = String(cr.field || "");
+        if (cf) {
+            cloneByField[cf] = String(cr.value === undefined || cr.value === null ? "" : cr.value);
+        }
+    }
+    var missing = [];
+    var notes = [];
+    for (var s = 0; s < sourceRows.length; s++) {
+        var sr = flattenRow(sourceRows[s]);
+        var sf = String(sr.field || "");
+        if (!sf) {
+            continue;
+        }
+        if (!Object.prototype.hasOwnProperty.call(cloneByField, sf)) {
+            missing.push(sf);
+            continue;
+        }
+        var sv = String(sr.value === undefined || sr.value === null ? "" : sr.value);
+        if (cloneByField[sf] !== sv) {
+            notes.push("output mapping '" + sf + "' differs on the clone: '" + cloneByField[sf] + "' (source '" + sv + "')");
+        }
+    }
+    if (missing.length > 0) {
+        notes.unshift(missing.length + " output mapping(s) missing on the clone (" + MAPPING_TABLE + "): " + missing.join(", "));
+    }
+    else if (sourceRows.length > 0) {
+        notes.unshift("all " + sourceRows.length + " output mapping(s) present on the clone");
+    }
+    return { ok: missing.length === 0, notes: notes };
+}
+/**
+ * Write one cloned sys_documentation row: update the existing (name, element,
+ * language) row on the target if the platform already made one, else create it.
+ */
+async function upsertLabel(client, op, updateSetSysId) {
+    var f = op.fields;
+    var keyParts = [String(f.name), String(f.element || ""), String(f.language || "")];
+    for (var k = 0; k < keyParts.length; k++) {
+        if (/[\^\r\n]/.test(keyParts[k])) {
+            throw new Error("cloneActionType: label key " + JSON.stringify(keyParts[k]) + " contains '^' or a line break.");
+        }
+    }
+    var query = "name=" + keyParts[0] + "^element=" + keyParts[1];
+    if (keyParts[2] !== "") {
+        query += "^language=" + keyParts[2];
+    }
+    try {
+        var hits = await client.table.query(LABEL_TABLE, query, { limit: 1, fields: ["sys_id"] });
+        var existingSysId = hits.length > 0 ? String(flattenRow(hits[0]).sys_id || "") : "";
+        if (RX_SYS_ID.test(existingSysId)) {
+            var update = Object.assign({}, f);
+            delete update.sys_id;
+            await client.claude.pushWithUpdateSet({
+                update_set_sys_id: updateSetSysId,
+                table: LABEL_TABLE,
+                record_sys_id: existingSysId,
+                fields: update,
+            });
+            return { id: op.id, logicalName: op.logicalName, table: op.table, sysId: existingSysId, action: "updated" };
+        }
+        var created = await client.claude.createRecord({
+            table: op.table,
+            fields: f,
+            scope: op.scope,
+            update_set_sys_id: updateSetSysId,
+            sys_id: String(f.sys_id),
+        });
+        return {
+            id: op.id,
+            logicalName: op.logicalName,
+            table: op.table,
+            sysId: created.sys_id ? String(created.sys_id) : String(f.sys_id),
+            action: "created",
+        };
+    }
+    catch (err) {
+        var msg = err instanceof Error ? err.message : String(err);
+        throw new Error("cloneActionType: label write failed at op '" + op.id + "' (" + op.table + "): " + msg);
+    }
+}

package/dist/flowDesigner/defineActionType.d.ts

@@ -301,5 +301,6 @@ export interface PlanActionDefinitionParams {
  * before/after views; throws on any invalid or dangling reference.
  */
 export declare function planActionDefinition(params: PlanActionDefinitionParams): DefineActionPlan;
+export declare function compareForVerify(expected: ActionView, actual: ActionView): DefineActionVerify;
 export declare function defineActionType(params: DefineActionTypeParams): Promise<DefineActionTypeResult>;
 export {};

package/dist/flowDesigner/defineActionType.js

@@ -50,6 +50,7 @@ exports.canonValue = canonValue;
 exports.viewAction = viewAction;
 exports.diffViews = diffViews;
 exports.planActionDefinition = planActionDefinition;
+exports.compareForVerify = compareForVerify;
 exports.defineActionType = defineActionType;
 const crypto_1 = require("crypto");
 const actionTypeApi_1 = require("./actionTypeApi");
@@ -1547,9 +1548,28 @@ async function resolveAliasDisplays(client, ids) {
     }
     return out;
 }
+// Variable attributes the server assigns a default to on save when the spec left
+// them unset (live-observed 2026-09-30: a new boolean input came back with
+// maxLength 40). A blank expected value for one of these is "unspecified", not a
+// mismatch; an explicitly specified value is still verified.
+var SERVER_DEFAULTED_FIELDS = ["maxLength"];
+function dropServerDefaults(changed) {
+    return changed
+        .map(function (c) {
+        var kept = c.changes.filter(function (f) {
+            return !(SERVER_DEFAULTED_FIELDS.indexOf(f.field) !== -1 && f.before === "");
+        });
+        return Object.assign({}, c, { changes: kept });
+    })
+        .filter(function (c) {
+        return c.changes.length > 0;
+    });
+}
 function compareForVerify(expected, actual) {
     var notes = [];
     var d = diffViews(expected, actual, {});
+    d.inputs.changed = dropServerDefaults(d.inputs.changed);
+    d.outputs.changed = dropServerDefaults(d.outputs.changed);
     // Expected -> actual: any difference means the save did not land as planned.
     d.action.forEach(function (c) {
         notes.push("action." + c.field + " is '" + c.after + "', expected '" + c.before + "'");
@@ -1585,10 +1605,13 @@ function compareForVerify(expected, actual) {
     d.steps.changed.forEach(function (s) {
         notes.push("step '" + s.label + "': " + s.changes.join("; "));
     });
-    if (notes.length === 0) {
+    // ok is derived from the filtered notes, not d.empty: server-defaulted fields
+    // were dropped above and must not fail the verify.
+    var ok = notes.length === 0;
+    if (ok) {
         notes.push("read-back matches the planned definition");
     }
-    return { ok: d.empty, notes: notes };
+    return { ok: ok, notes: notes };
 }
 async function defineActionType(params) {
     var client = params.client;

package/dist/flowDesigner/writeOrder.d.ts

@@ -36,8 +36,12 @@ export interface WriteOpResult {
     logicalName: string;
     table: string;
     sysId: string;
-    /** Currently always "created" — claude.createRecord doesn't distinguish. */
-    action: "created";
+    /**
+     * executeWritePlan always reports "created" — claude.createRecord doesn't
+     * distinguish. "updated" is reported by callers that upsert (cloneActionType's
+     * label rows, which the platform may already have created on the dictionary insert).
+     */
+    action: "created" | "updated";
 }
 export declare class WriteOrderError extends Error {
     readonly cycleIds?: Array<string> | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenonhq/dovetail-servicenow",
-  "version": "0.0.43",
+  "version": "0.0.45",
   "engines": {
     "node": ">=22"
   },