@uipath/maestro-builder-sdk 6.66.6 → 6.66.8

package/dist/bindings-v2.d.ts

@@ -1,3 +1,4 @@
+import type { ConnectionUse } from './core/compile-refusal.js';
 /** One declared solution resource. */
 export interface BindingsV2Resource {
     resource: string;
@@ -26,9 +27,22 @@ export interface BindingsV2Document {
  * connector — are refused with `CONNECTION_CONNECTOR_CONFLICT`: at most one of
  * them can run, and picking the first silently mislabels the solution resource.
  *
+ * A collect-mode stand-in (`check` with no library) has no `detail`; `standIns`
+ * gives the connection it was bound to, by node id, so it is judged here like
+ * any node and `check` reports the conflict without a library.
+ *
+ * The bound-connection filter is not applied to a stand-in because a stand-in
+ * has no binding row to find. That does not make `check` stricter for the
+ * common case: with a library, a connector node writes its own ConnectionId row
+ * keyed by its connection id, a literal id with no bindings.json entry included
+ * (`connectionResourceBindings`), so the same id is in `bound` and compile
+ * refuses the same conflict. The one input where the two differ is a node whose
+ * definition declares no connection binding at all: compile skips it, the
+ * stand-in cannot know that without the definition.
+ *
  * @throws BindingRefusal when two nodes on one connection name different connectors.
  */
-export declare function connectionConnectors(flow: unknown): Map<string, string>;
+export declare function connectionConnectors(flow: unknown, standIns?: ReadonlyMap<string, ConnectionUse>): Map<string, string>;
 /**
  * The `connection` resources a compiled flow declares — one per distinct
  * connection, in node order, attributed to the FIRST node that uses it.

package/dist/bindings-v2.js

@@ -118,9 +118,22 @@ function allNodes(flow) {
  * connector — are refused with `CONNECTION_CONNECTOR_CONFLICT`: at most one of
  * them can run, and picking the first silently mislabels the solution resource.
  *
+ * A collect-mode stand-in (`check` with no library) has no `detail`; `standIns`
+ * gives the connection it was bound to, by node id, so it is judged here like
+ * any node and `check` reports the conflict without a library.
+ *
+ * The bound-connection filter is not applied to a stand-in because a stand-in
+ * has no binding row to find. That does not make `check` stricter for the
+ * common case: with a library, a connector node writes its own ConnectionId row
+ * keyed by its connection id, a literal id with no bindings.json entry included
+ * (`connectionResourceBindings`), so the same id is in `bound` and compile
+ * refuses the same conflict. The one input where the two differ is a node whose
+ * definition declares no connection binding at all: compile skips it, the
+ * stand-in cannot know that without the definition.
+ *
  * @throws BindingRefusal when two nodes on one connection name different connectors.
  */
-export function connectionConnectors(flow) {
+export function connectionConnectors(flow, standIns = new Map()) {
     const out = new Map();
     if (!isRecord(flow))
         return out;
@@ -133,11 +146,21 @@ export function connectionConnectors(flow) {
     const users = new Map();
     for (const node of allNodes(flow)) {
         const detail = nodeDetail(node);
-        const key = detail && nodeConnectionKey(detail);
-        if (!detail || !key || !bound.has(key))
-            continue;
-        const connector = nodeConnectionConnector(detail);
-        if (!connector)
+        const standIn = typeof node.id === 'string' && isRecord(node.inputs) && node.inputs.standIn === true
+            ? standIns.get(node.id) : undefined;
+        let key;
+        let connector;
+        if (standIn) {
+            key = standIn.connection;
+            connector = standIn.connector;
+        }
+        else {
+            key = detail && nodeConnectionKey(detail);
+            if (!detail || !key || !bound.has(key))
+                continue;
+            connector = nodeConnectionConnector(detail);
+        }
+        if (!key || !connector)
             continue;
         const byConnector = users.get(key) ?? new Map();
         users.set(key, byConnector);

package/dist/bpmn/check.js

@@ -1,9 +1,8 @@
-import { nodeDeclaredVars } from './declared-vars.js';
-import { allNodes, folderCompanionKeys, implicitNodeVars, processId } from './serialize.js';
+import { allNodes, documentIdProblems, folderCompanionKeys, implicitNodeVars, processId } from './serialize.js';
 import { KNOWN_METHOD_SET } from './known-methods.js';
 import { EQUALS_EXPR_DIALECT, checkConnectorContract, checkConnectorLookups, checkConnectorSchema, checkBindingLabels, } from '../core/connector-checks.js';
 import { checkEventResolution, checkEventSubscription, eventParamsFor, } from '../core/event-checks.js';
-import { bindingRequiredFields, CASE_RUNTIME_INTERNAL_TYPES, missingRequiredContext, missingRequiredInputs, REGISTRY_GAPS, registryType, } from './typed-node.js';
+import { bindingRequiredFields, CASE_RUNTIME_INTERNAL_TYPES, CONNECTOR_ACTIVITY_TYPES, connectorInputsShadowed, missingRequiredContext, missingRequiredInputs, REGISTRY_GAPS, registryType, } from './typed-node.js';
 import { ownEntry } from '../core/own-entry.js';
 import { isManagedHttpV2, managedHttpAbsoluteUrl, managedHttpMissing } from './managed-http.js';
 /**
@@ -60,13 +59,13 @@ const GATEWAY_KINDS = new Set(['exclusiveGateway', 'parallelGateway', 'inclusive
 const ACTIVITY_KINDS = new Set(['task', 'scriptTask', 'subProcess', 'connector', 'typed', 'connectorEvent', 'externalTask']);
 export function check(built, opts = {}) {
     const diags = [];
-    if (!built.id)
-        diags.push({ level: 'error', code: 'NO_ID', message: 'bpmn() requires an id.' });
-    const seenIds = new Set();
-    checkScope(built.nodes, built.flows, 'process', diags, seenIds, true);
+    // The rule lives in serialize.ts `documentIdProblems`; this check does not serialize.
+    for (const p of documentIdProblems(built)) {
+        diags.push({ level: 'error', code: p.code, message: p.message, ...(p.where ? { where: p.where } : {}) });
+    }
+    checkScope(built.nodes, built.flows, 'process', diags, true);
     checkScopedVars(built, diags);
     checkVariableOrder(built, diags);
-    checkDocumentIds(built, diags);
     checkFolderBindings(built, diags);
     checkIntsvcActivities(built, diags);
     checkEntryPointId(built, diags);
@@ -237,8 +236,6 @@ function checkMethodParentheses(built, diags) {
     };
     walk(built.nodes, built.flows);
 }
-/** The Integration Service activity types, whose payload rows the platform reads only by `target`. */
-const CONNECTOR_ACTIVITY_TYPES = new Set(['Intsvc.ActivityExecution', 'Intsvc.AsyncExecution']);
 /**
  * The targets the platform's reader knows (`UiPathExtensionsProvider`): anything else —
  * an empty string included — falls through its switch to `Body`, and the row becomes the
@@ -256,23 +253,18 @@ const PLATFORM_ROW_TARGETS = new Set(['body', 'bodyField', 'header', 'path', 'qu
  * while the v1 arm's `<uipath:input name="body" target="body">{"script":"…"}</uipath:input>`
  * ran. `inputs: { script }` folds a request field into the body row, so the remedy is
  * the plain record for a body field, or the row's own target when it is a real slot.
- * And because an `inputRows` list REPLACES `inputs` at emission (typed-node.ts), a
- * node that sets both silently drops every `inputs` field — the same live fault.
+ * And because an `inputRows` list REPLACES `inputs` at emission, a node that sets both
+ * would drop every `inputs` field — the same live fault — so the serializer refuses it
+ * (typed-node.ts `connectorInputsShadowed`).
  */
 function checkConnectorRows(built, diags) {
     for (const n of allNodes(built.nodes)) {
         if (n.kind !== 'typed' || !CONNECTOR_ACTIVITY_TYPES.has(n.type))
             continue;
-        if (n.inputRows && Object.keys(n.inputs ?? {}).length > 0) {
-            diags.push({
-                level: 'error',
-                code: 'CONNECTOR_INPUTS_SHADOWED',
-                where: n.id,
-                message: `Connector activity "${n.id}" sets both \`inputs\` (${Object.keys(n.inputs).map((k) => `"${k}"`).join(', ')}) and \`inputRows\`; ` +
-                    `an \`inputRows\` list replaces \`inputs\` entirely at emission, so those fields are never sent. Spell them as rows too ` +
-                    `(a body field as \`{ name: 'body', type: 'json', target: 'body', body: { … } }\`), or drop \`inputRows\` and write every field in \`inputs\`.`,
-            });
-        }
+        // The rule lives in typed-node.ts `connectorInputsShadowed`.
+        const shadowed = connectorInputsShadowed(n.id, n.type, n.inputs, n.inputRows);
+        if (shadowed)
+            diags.push({ level: 'error', code: 'CONNECTOR_INPUTS_SHADOWED', where: n.id, message: shadowed });
         for (const row of n.inputRows ?? []) {
             const target = row.target ?? '';
             if (target === '') {
@@ -628,85 +620,6 @@ function checkIntsvcActivities(built, diags) {
         }
     }
 }
-/**
- * Every `id` in the document must be unique — including across KINDS.
- *
- * Not a style rule. `bpmn-moddle` keeps one document-global id registry, so a
- * second use of an id makes its whole element **unparsable**, and it drops it:
- *
- *     unparsable content <bpmn:task> detected … nested error: duplicate ID <after>
- *
- * `.var('after', …)` next to `.task('after', …)` therefore emits a `.bpmn` whose
- * task simply is not there. Both validators still pass it — the canvas one
- * downgrades the now-dangling flows to warnings and `uip maestro bpmn validate`
- * reports `Valid` — and the runtime then dies with `Unknown element 'after'`, or
- * worse, silently does no work if nothing else routes through the hole. So this
- * is the only gate that can catch it, and it has to be an error.
- *
- * The ids in play are every element and flow, every variable and binding, the
- * synthesized `Message_n`/`Error_n` declarations, and the process itself — and the
- * declarations serialize DERIVES from output rows (a connector's `<id>_response`, a
- * script task's `outputs`), which are variables in the document too. Those were the one
- * kind this check could not see: a script output named after the gateway that routes
- * on it (`outputs: { confidence }` beside `.choose('confidence', …)`) passed here and
- * every SDK gate, and `uip maestro bpmn validate` answered with three
- * CROSSING_SUBPROCESS_BOUNDARY errors on the gateway's flows — the validator had
- * resolved the id to the variable. Measured on the nested_review port.
- */
-function checkDocumentIds(built, diags) {
-    const owners = new Map();
-    const claim = (id, kind) => {
-        const existing = owners.get(id);
-        if (existing === undefined) {
-            owners.set(id, kind);
-            return;
-        }
-        diags.push({
-            level: 'error',
-            code: 'DUPLICATE_DOCUMENT_ID',
-            message: `id "${id}" is used by both ${existing} and ${kind}. Every id in a .bpmn must be unique — ` +
-                `the XML parser drops the second element that reuses one, so it disappears from the process.`,
-            where: id,
-        });
-    };
-    claim(built.id, 'the process');
-    const owner = (nodes, id) => nodes.find((n) => nodeDeclaredVars(n).includes(id))?.id ?? '?';
-    // A sub-process row's variable counts as declared when serialize's createSubProcess
-    // sees it so: the root's declarations, implied ones included, and every sub-process's own.
-    const rootImplied = implicitNodeVars(built.nodes, built.variables);
-    const declared = [
-        ...built.variables,
-        ...rootImplied,
-        ...allNodes(built.nodes).flatMap((n) => (n.kind === 'subProcess' ? n.variables : [])),
-    ];
-    const walk = (nodes, flows) => {
-        for (const n of nodes) {
-            claim(n.id, `element "${n.id}"`);
-            if (n.kind === 'subProcess') {
-                for (const v of n.variables)
-                    claim(v.id, `variable "${v.id}"`);
-                for (const v of implicitNodeVars(n.nodes, [...n.variables, ...declared])) {
-                    claim(v.id, `the variable serialize declares for the output row of "${owner(n.nodes, v.id)}"`);
-                }
-                walk(n.nodes, n.flows);
-            }
-        }
-        for (const f of flows)
-            claim(f.id, `flow "${f.id}"`);
-    };
-    walk(built.nodes, built.flows);
-    for (const v of built.variables)
-        claim(v.id, `variable "${v.id}"`);
-    for (const v of rootImplied) {
-        claim(v.id, `the variable serialize declares for the output row of "${owner(built.nodes, v.id)}"`);
-    }
-    for (const b of built.bindings)
-        claim(b.id, `binding "${b.id}"`);
-    for (const mm of built.messages)
-        claim(mm.id, `message "${mm.name}"`);
-    for (const e of built.errors)
-        claim(e.id, `error "${e.name}"`);
-}
 /**
  * A pinned declaration order must name the declarations it is ordering.
  *
@@ -1021,7 +934,7 @@ function checkActivityFields(n, diags) {
             });
     }
 }
-function checkScope(nodes, flows, where, diags, seenIds, isTop, 
+function checkScope(nodes, flows, where, diags, isTop, 
 /**
  * Whether the CONTAINER of these nodes is an event sub-process. The process root
  * never is, so it defaults false — see ERROR_START_OUTSIDE_EVENT_SUBPROCESS below.
@@ -1030,11 +943,6 @@ inEventSubProcess = false) {
     const nodeIds = new Set();
     for (const n of nodes)
         nodeIds.add(n.id);
-    // Duplicate ids (globally across the document).
-    for (const n of nodes)
-        dupId(n.id, seenIds, diags, where);
-    for (const f of flows)
-        dupId(f.id, seenIds, diags, where);
     // At least one start event per scope that has any nodes.
     //
     // "Start event" is the ELEMENT, not the builder kind. A registry-backed node can
@@ -1472,7 +1380,7 @@ inEventSubProcess = false) {
         }
         // Recurse into sub-process bodies.
         if (n.kind === 'subProcess')
-            checkScope(n.nodes, n.flows, `subProcess "${n.id}"`, diags, seenIds, false, n.triggeredByEvent === true);
+            checkScope(n.nodes, n.flows, `subProcess "${n.id}"`, diags, false, n.triggeredByEvent === true);
     }
 }
 /**
@@ -1500,8 +1408,3 @@ function isStartElement(n) {
         return false;
     }
 }
-function dupId(id, seen, diags, where) {
-    if (seen.has(id))
-        diags.push({ level: 'error', code: 'DUP_ID', message: `Duplicate element id "${id}" in ${where}.`, where: id });
-    seen.add(id);
-}

package/dist/bpmn/serialize.d.ts

@@ -24,6 +24,47 @@ export declare function serialize(built: BuiltBpmn, opts?: BpmnSerializeOpts): P
  * of the trade. Revisit if the graders learn to treat absence as interrupting.
  */
 export declare function finalizeBpmnXml(xml: string): string;
+/** One id problem in a process: the code, its message, and the id it is about. */
+export interface DocumentIdProblem {
+    code: 'BPMN_NO_ID' | 'DUP_ID' | 'DUPLICATE_DOCUMENT_ID';
+    message: string;
+    where: string;
+}
+/**
+ * Every id the `.bpmn` would get wrong, in document order. `serialize` refuses the
+ * first; `check` reports them all. One rule for both, because BPMN `check` does not
+ * run the serializer.
+ *
+ * - `BPMN_NO_ID`: an empty process id. `processId` would write the invented
+ *   `Process_1`, a process the source does not name (decompile then writes
+ *   `bpmn("Process_1")`). Flow's and Case's `NO_ID` stay `lint`: their files keep
+ *   the empty id, or never carry it.
+ * - `DUP_ID`: two elements or sequence flows with one id.
+ * - `DUPLICATE_DOCUMENT_ID`: any other id used twice: an element and a variable,
+ *   two variables, a binding, a message, an error, the process.
+ *
+ * Not style rules. `bpmn-moddle` keeps one document-global id registry, so a
+ * second use of an id makes its whole element **unparsable**, and it drops it:
+ *
+ *     unparsable content <bpmn:task> detected … nested error: duplicate ID <after>
+ *
+ * `.var('after', …)` next to `.task('after', …)` therefore emits a `.bpmn` whose
+ * task simply is not there. Both validators still pass it — the canvas one
+ * downgrades the now-dangling flows to warnings and `uip maestro bpmn validate`
+ * reports `Valid` — and the runtime then dies with `Unknown element 'after'`, or
+ * worse, silently does no work if nothing else routes through the hole.
+ *
+ * The ids in play are every element and flow, every variable and binding, the
+ * synthesized `Message_n`/`Error_n` declarations, and the process itself (its id
+ * as written, `processId`) — and the declarations this file DERIVES from output
+ * rows (a connector's `<id>_response`, a script task's `outputs`), which are
+ * variables in the document too. A script output named after the gateway that
+ * routes on it (`outputs: { confidence }` beside `.choose('confidence', …)`) once
+ * passed every SDK gate, and `uip maestro bpmn validate` answered with three
+ * CROSSING_SUBPROCESS_BOUNDARY errors on the gateway's flows — the validator had
+ * resolved the id to the variable. Measured on the nested_review port.
+ */
+export declare function documentIdProblems(built: BuiltBpmn): DocumentIdProblem[];
 export declare function processId(id: string): string;
 /**
  * The `args` keys every Studio Web script task carries, in the order the designer writes

package/dist/bpmn/serialize.js

@@ -18,7 +18,7 @@ import { createRequire } from 'node:module';
 import { createConnectorTask } from './connector.js';
 import { createConnectorEvent, createExternalTask, intsvcOutputVar } from './intsvc.js';
 import { createExtensionPayload, createTypedNode, rowDeclaration, typedNodeOutputVar, verbatimOutputRows } from './typed-node.js';
-import { connectorOutputVars, typedNodeDeclaredVars } from './declared-vars.js';
+import { connectorOutputVars, nodeDeclaredVars, typedNodeDeclaredVars } from './declared-vars.js';
 import { defaultEntryPointId } from './entry-point-id.js';
 import { parseXmlRanges } from './xml-ranges.js';
 import { ownEntry } from '../core/own-entry.js';
@@ -53,6 +53,11 @@ function mapType(t) {
     }
 }
 export async function serialize(built, opts = {}) {
+    // compile writes what this returns, and since #1497 nothing runs `check` first
+    // on every path, so a document this would write wrong is refused here.
+    const [problem] = documentIdProblems(built);
+    if (problem)
+        throw new CompileRefusal(problem.code, problem.message);
     const m = new BpmnModdle({ uipath: uipathDescriptor });
     const messageById = new Map();
     const messages = built.messages.map((mm) => {
@@ -308,6 +313,103 @@ function cdata(name, text) {
     }
     return `<![CDATA[${escaped}]]>`;
 }
+/**
+ * Every id the `.bpmn` would get wrong, in document order. `serialize` refuses the
+ * first; `check` reports them all. One rule for both, because BPMN `check` does not
+ * run the serializer.
+ *
+ * - `BPMN_NO_ID`: an empty process id. `processId` would write the invented
+ *   `Process_1`, a process the source does not name (decompile then writes
+ *   `bpmn("Process_1")`). Flow's and Case's `NO_ID` stay `lint`: their files keep
+ *   the empty id, or never carry it.
+ * - `DUP_ID`: two elements or sequence flows with one id.
+ * - `DUPLICATE_DOCUMENT_ID`: any other id used twice: an element and a variable,
+ *   two variables, a binding, a message, an error, the process.
+ *
+ * Not style rules. `bpmn-moddle` keeps one document-global id registry, so a
+ * second use of an id makes its whole element **unparsable**, and it drops it:
+ *
+ *     unparsable content <bpmn:task> detected … nested error: duplicate ID <after>
+ *
+ * `.var('after', …)` next to `.task('after', …)` therefore emits a `.bpmn` whose
+ * task simply is not there. Both validators still pass it — the canvas one
+ * downgrades the now-dangling flows to warnings and `uip maestro bpmn validate`
+ * reports `Valid` — and the runtime then dies with `Unknown element 'after'`, or
+ * worse, silently does no work if nothing else routes through the hole.
+ *
+ * The ids in play are every element and flow, every variable and binding, the
+ * synthesized `Message_n`/`Error_n` declarations, and the process itself (its id
+ * as written, `processId`) — and the declarations this file DERIVES from output
+ * rows (a connector's `<id>_response`, a script task's `outputs`), which are
+ * variables in the document too. A script output named after the gateway that
+ * routes on it (`outputs: { confidence }` beside `.choose('confidence', …)`) once
+ * passed every SDK gate, and `uip maestro bpmn validate` answered with three
+ * CROSSING_SUBPROCESS_BOUNDARY errors on the gateway's flows — the validator had
+ * resolved the id to the variable. Measured on the nested_review port.
+ */
+export function documentIdProblems(built) {
+    const problems = [];
+    if (!built.id)
+        problems.push({ code: 'BPMN_NO_ID', message: 'bpmn() requires an id.', where: '' });
+    /** id → who holds it, and whether that holder is an element or a flow. */
+    const owners = new Map();
+    const claim = (id, kind, element = undefined) => {
+        const existing = owners.get(id);
+        if (existing === undefined) {
+            owners.set(id, { kind, element: element !== undefined });
+            return;
+        }
+        if (element && existing.element) {
+            problems.push({ code: 'DUP_ID', message: `Duplicate element id "${id}" in ${element.scope}.`, where: id });
+            return;
+        }
+        problems.push({
+            code: 'DUPLICATE_DOCUMENT_ID',
+            message: `id "${id}" is used by both ${existing.kind} and ${kind}. Every id in a .bpmn must be unique — ` +
+                `the XML parser drops the second element that reuses one, so it disappears from the process.`,
+            where: id,
+        });
+    };
+    if (built.id)
+        claim(processId(built.id), 'the process');
+    const owner = (nodes, id) => nodes.find((n) => nodeDeclaredVars(n).includes(id))?.id ?? '?';
+    // A sub-process row's variable counts as declared when createSubProcess sees it
+    // so: the root's declarations, implied ones included, and every sub-process's own.
+    const rootImplied = implicitNodeVars(built.nodes, built.variables);
+    const declared = [
+        ...built.variables,
+        ...rootImplied,
+        ...allNodes(built.nodes).flatMap((n) => (n.kind === 'subProcess' ? n.variables : [])),
+    ];
+    const walk = (nodes, flows, scope) => {
+        for (const n of nodes) {
+            claim(n.id, `element "${n.id}"`, { scope });
+            if (n.kind === 'subProcess') {
+                for (const v of n.variables)
+                    claim(v.id, `variable "${v.id}"`);
+                for (const v of implicitNodeVars(n.nodes, [...n.variables, ...declared])) {
+                    claim(v.id, `the variable serialize declares for the output row of "${owner(n.nodes, v.id)}"`);
+                }
+                walk(n.nodes, n.flows, `subProcess "${n.id}"`);
+            }
+        }
+        for (const f of flows)
+            claim(f.id, `flow "${f.id}"`, { scope });
+    };
+    walk(built.nodes, built.flows, 'process');
+    for (const v of built.variables)
+        claim(v.id, `variable "${v.id}"`);
+    for (const v of rootImplied) {
+        claim(v.id, `the variable serialize declares for the output row of "${owner(built.nodes, v.id)}"`);
+    }
+    for (const b of built.bindings)
+        claim(b.id, `binding "${b.id}"`);
+    for (const mm of built.messages)
+        claim(mm.id, `message "${mm.name}"`);
+    for (const e of built.errors)
+        claim(e.id, `error "${e.name}"`);
+    return problems;
+}
 export function processId(id) {
     return /^[A-Za-z_][\w.-]*$/.test(id) ? id : 'Process_1';
 }

package/dist/bpmn/typed-node.d.ts

@@ -328,6 +328,18 @@ export interface TypedOutputRow {
      */
     target?: string;
 }
+/** The Integration Service activity types, whose payload rows the platform reads only by `target`. */
+export declare const CONNECTOR_ACTIVITY_TYPES: ReadonlySet<string>;
+/**
+ * CONNECTOR_INPUTS_SHADOWED's message when a connector activity sets both `inputs`
+ * and `inputRows`, else `undefined`.
+ *
+ * An `inputRows` list replaces `inputs` at emission (`createTypedNode`), so writing
+ * the node would silently drop every `inputs` field, and the live call then faults
+ * on the missing parameter. `createTypedNode` refuses it; `check` reports the same
+ * condition from this function, because BPMN `check` does not serialize.
+ */
+export declare function connectorInputsShadowed(id: string, type: string, inputs: Record<string, unknown> | undefined, rows: readonly unknown[] | undefined): string | undefined;
 /** What an author supplies for a typed node, on top of its id. */
 export interface TypedNodeInput {
     /** Display name the designer shows. */

package/dist/bpmn/typed-node.js

@@ -193,6 +193,27 @@ export function rowDeclaration(row) {
     const wire = type === 'object' || type === 'array' || type === 'any' ? 'json' : type;
     return { type, wire, name: row.name, schema: row.varSchema };
 }
+/** The Integration Service activity types, whose payload rows the platform reads only by `target`. */
+export const CONNECTOR_ACTIVITY_TYPES = new Set(['Intsvc.ActivityExecution', 'Intsvc.AsyncExecution']);
+/**
+ * CONNECTOR_INPUTS_SHADOWED's message when a connector activity sets both `inputs`
+ * and `inputRows`, else `undefined`.
+ *
+ * An `inputRows` list replaces `inputs` at emission (`createTypedNode`), so writing
+ * the node would silently drop every `inputs` field, and the live call then faults
+ * on the missing parameter. `createTypedNode` refuses it; `check` reports the same
+ * condition from this function, because BPMN `check` does not serialize.
+ */
+export function connectorInputsShadowed(id, type, inputs, rows) {
+    if (!CONNECTOR_ACTIVITY_TYPES.has(type) || !rows)
+        return undefined;
+    const keys = Object.keys(inputs ?? {});
+    if (keys.length === 0)
+        return undefined;
+    return (`Connector activity "${id}" sets both \`inputs\` (${keys.map((k) => `"${k}"`).join(', ')}) and \`inputRows\`; ` +
+        `an \`inputRows\` list replaces \`inputs\` entirely at emission, so those fields are never sent. Spell them as rows too ` +
+        `(a body field as \`{ name: 'body', type: 'json', target: 'body', body: { … } }\`), or drop \`inputRows\` and write every field in \`inputs\`.`);
+}
 /**
  * An output name reduced to something an expression can actually read.
  *
@@ -548,6 +569,9 @@ varType) {
     // Spelled out by the caller: emit exactly these rows, deriving nothing — see
     // TypedNodeInput.inputRows. This is what lets a connector's per-parameter rows
     // (`name="start" type="string" value="0" target="query"`) survive a round trip.
+    const shadowed = connectorInputsShadowed(id, type, input.inputs, input.inputRows);
+    if (shadowed)
+        throw new CompileRefusal('CONNECTOR_INPUTS_SHADOWED', shadowed);
     const ins = input.inputRows ? verbatimInputRows(m, input.inputRows) : inputRows(m, spec, input.inputs ?? {});
     if (ins.length)
         payload.input = ins;

package/dist/case/check.js

@@ -8,18 +8,8 @@ import { EQUALS_EXPR_DIALECT, checkBindingLabels, checkConnectorContract, checkC
 import { checkEventResolution } from '../core/event-checks.js';
 import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, EXTERNAL_TASK_HYBRID_UNSUPPORTED, externalHybridRefusal, isExternalExecutionMode } from './external.js';
 import { isResourceLabelRefusal, resolveResourceRef } from './resource-identity.js';
+import { taskShapeProblems } from './task-shape.js';
 const TYPE_NAMES = new Set(Object.values(types));
-/**
- * Every key an `ActionField` takes. `compile` writes only these onto the form
- * row, so any other key would be dropped without a word (builder-sdk#1422): an
- * author who adds the Designer's row keys (`id`, `var`, `source`) sees `check`
- * and `compile` pass and the row come out unchanged. The `satisfies` keeps this
- * list and the interface in step: a key added to one and not the other fails to
- * type-check.
- */
-const ACTION_FIELD_KEYS = new Set(Object.keys({
-    name: true, type: true, subType: true, displayName: true, value: true, required: true, options: true,
-}));
 // audit-case-coverage: rule-slot table start
 // This runtime table must equal the committed matrix's rejected cells. The audit
 // parses these object literals; the product-pin matrix currently rejects none.
@@ -509,17 +499,10 @@ function checkStage(stage, diags, refStage, refPlacement, bindings) {
             where: stage.label,
         });
     for (const t of tasks) {
-        if (t.kind === 'wait-for-timer') {
-            const timerValues = [t.timer?.duration, t.timer?.date, t.timer?.cycle]
-                .filter((value) => typeof value === 'string' && value.trim().length > 0);
-            if (timerValues.length !== 1)
-                diags.push({
-                    level: 'error',
-                    code: 'TIMER_VALUE_REQUIRED',
-                    message: `Timer task "${t.name}" needs exactly one non-empty duration, date, or cycle. For a validating stand-in, use .waitForTimer({ duration: 'PT1M' }).`,
-                    where: t.name,
-                });
-        }
+        // A timer with no or several values, an action field key compile does not
+        // write: serialize refuses the same shapes with the same text (task-shape.ts).
+        for (const problem of taskShapeProblems(t))
+            diags.push({ level: 'error', code: problem.code, message: problem.message, where: t.name });
         const invalidBinding = [...(t.inputs ?? []), ...(t.outputs ?? [])]
             .find((binding) => !TYPE_NAMES.has(binding.type));
         if (invalidBinding)
@@ -681,24 +664,6 @@ function checkStage(stage, diags, refStage, refPlacement, bindings) {
                 message: `Action field "${emptyRequiredField.name}" in task "${t.name}" is required but has no value. Set its value or remove required: true; required does not mean reviewer-must-fill.`,
                 where: t.name,
             });
-        for (const [side, fields] of [['input', t.action?.inputs], ['output', t.action?.outputs]])
-            for (const field of fields ?? []) {
-                const unknown = Object.keys(field)
-                    .filter((key) => !ACTION_FIELD_KEYS.has(key) && field[key] !== undefined);
-                if (!unknown.length)
-                    continue;
-                diags.push({
-                    level: 'error',
-                    code: 'ACTION_FIELD_UNKNOWN_KEY',
-                    message: `Action ${side} field "${String(field.name)}" in task "${t.name}" has ${unknown.length === 1 ? 'a key' : 'keys'} ` +
-                        `${unknown.map((key) => `"${key}"`).join(', ')} that an action field does not take, so compile would drop ${unknown.length === 1 ? 'it' : 'them'}. ` +
-                        `An action field takes ${[...ACTION_FIELD_KEYS].join(', ')}. ` +
-                        (side === 'output'
-                            ? `To choose the case variable an output writes, set value: '<variable>'; compile writes the row's id, var, source and target from it.`
-                            : `An input's value is the literal or =vars.<name> expression the assignee sees.`),
-                    where: t.name,
-                });
-            }
         if (t.entry.length === 0)
             diags.push({
                 level: 'error',

package/dist/case/serialize.js

@@ -31,6 +31,7 @@ import { readEventFilterLeaf, eventFilterTreeLeaf } from '../core/event-filters.
 import { responseJsonSchema } from '../core/connector-response-schema.js';
 import { ruleShapeProblems } from './rule-options.js';
 import { CompileRefusal } from '../core/compile-refusal.js';
+import { taskShapeProblems } from './task-shape.js';
 /** The ids a serialize pass hashed from element ids, by the document it returned. */
 const ELEMENT_SEEDED_IDS = new WeakMap();
 function elementSeededId(resolver, elementId, suffix) {
@@ -1148,6 +1149,11 @@ function emitTask(task, stageLabel, taskId, ids, resolver) {
     return node;
 }
 function taskData(task, resolver, taskId, stageId, ids) {
+    // A timer with no or several values, or an action field key the row has no
+    // place for, cannot be written as authored: refuse it, as `check` does (#1518).
+    const [shape] = taskShapeProblems(task);
+    if (shape)
+        throw new CompileRefusal(shape.code, shape.message);
     switch (task.kind) {
         case 'process':
         case 'agent':

package/dist/case/task-shape.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The task shapes Case `check` reports and `serialize` refuses, because the
+ * caseplan cannot say what the source says (#1518):
+ *
+ *   - `TIMER_VALUE_REQUIRED`: a wait-for-timer task sets exactly one of
+ *     duration, date or cycle, and that one is non-blank. With two, serialize writes the first and drops
+ *     the rest (`{ duration: 'PT1M', date: '2027-…' }` came out as
+ *     `timeDuration: 'PT1M'` alone); with none, it writes `data: {}`, which
+ *     product validation refuses.
+ *   - `ACTION_FIELD_UNKNOWN_KEY`: an action form field takes only the
+ *     `ActionField` keys; serialize writes only those, so any other key
+ *     (`default: 5`, the Designer's `id`/`var`/`source`) was dropped without a
+ *     word (#1422).
+ *
+ * Case `check` does not run the serializer, so both call these functions: one
+ * rule, one place, the same code and message from each.
+ */
+import type { BuiltTask } from './case-sdk.js';
+/** One problem with a task's shape. */
+export interface TaskShapeProblem {
+    code: 'TIMER_VALUE_REQUIRED' | 'ACTION_FIELD_UNKNOWN_KEY';
+    message: string;
+}
+/**
+ * Every problem with `task`'s shape, in a fixed order: the timer first, then
+ * each action input field, then each output field.
+ *
+ * @param task - The task as the builder recorded it.
+ * @returns The problems, empty when the task is well formed.
+ */
+export declare function taskShapeProblems(task: BuiltTask): TaskShapeProblem[];