@uipath/maestro-builder-sdk 6.54.1 → 6.56.0

package/dist/bpmn/human-task-form.js

@@ -0,0 +1,321 @@
+import { FORM_FIELD_TYPES, formFieldJsonSchema, formFieldOptionsProblem, formFieldOptionsWhy, formFieldSettingProblems, formFieldSettingsWire, formFieldTypeHint, liftFormFieldSettings, validFormFieldTypesText, wireFormFieldType, } from '../core/form-field-type.js';
+import { outcomeIdOf } from '../core/hitl-routing.js';
+import { schemaId as stableSchemaId } from '../core/stable-id.js';
+/** The `uipath:type` version both the converter and Studio Web write for `Actions.HITL`. */
+const QUICK_TYPE_VERSION = 'v2';
+/** The response row the app variant derives from the registry; the quick form keeps it. */
+const RESPONSE_ROW = 'Process response';
+const DRAFT_07 = 'http://json-schema.org/draft-07/schema#';
+/**
+ * A field id has to be a plain, unreserved identifier, for two reasons.
+ *
+ * An answer is read back as the bare expression `=<id>`, and `=review-note` is a
+ * subtraction. And the local evaluator makes every key of the response a PARAMETER of
+ * one `new Function(...keys, body)`, so a single key that cannot be a parameter name —
+ * `review-note`, `default`, `true` — throws for every output row of the task, the
+ * outcome mapping included, and `applyOutputs` writes `undefined` for all of them.
+ */
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+/** Words a parameter cannot be named: ECMAScript's reserved words, strict-mode ones, and the literal-like globals. */
+const RESERVED_WORDS = new Set([
+    'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do', 'else',
+    'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'new',
+    'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with',
+    'yield', 'let', 'static', 'implements', 'interface', 'package', 'private', 'protected', 'public',
+    'arguments', 'eval', 'undefined', 'NaN', 'Infinity',
+]);
+/** The response's own key for the outcome picked — an answer cannot claim it. */
+const OUTCOME_KEY = 'Action';
+/** Whether a field is shown to the reviewer (its value is sent). */
+function isShown(f) {
+    return f.direction === 'input' || f.direction === 'inOut';
+}
+/** Whether a field comes back as an answer. */
+function isAnswer(f) {
+    return f.direction === 'output' || f.direction === 'inOut';
+}
+/**
+ * A shown value as the form schema's `binding`: the variable PATH the designer reads
+ * (`vars.amount`), when the expression is one; otherwise the expression as written.
+ */
+function bindingOf(value) {
+    const path = /^=(?:js:)?(vars\.[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)$/.exec(value);
+    return path ? path[1] : value;
+}
+/** An output row's type for a field: its JSON Schema type, with structures as `json`. */
+function rowTypeOf(type) {
+    const json = formFieldJsonSchema(type)?.type ?? 'string';
+    return json === 'object' || json === 'array' ? 'json' : json;
+}
+/**
+ * Refuse a form the engine could not render, at the call that wrote it.
+ *
+ * @throws Error naming the task and what is wrong.
+ */
+function validate(id, input) {
+    const { form } = input;
+    const where = `humanTask "${id}"`;
+    if (!Array.isArray(form.fields))
+        throw new Error(`${where}: form.fields must be an array.`);
+    if (!Array.isArray(form.outcomes) || form.outcomes.length === 0) {
+        throw new Error(`${where}: the form needs at least one outcome, e.g. outcomes: ['Approve', 'Reject'].`);
+    }
+    const ids = new Set();
+    for (const f of form.fields) {
+        if (typeof f.id !== 'string' || f.id === '')
+            throw new Error(`${where}: every form field needs an id.`);
+        if (ids.has(f.id))
+            throw new Error(`${where}: form field id "${f.id}" is used twice.`);
+        ids.add(f.id);
+        if (f.id === OUTCOME_KEY) {
+            throw new Error(`${where}: form field "${OUTCOME_KEY}" collides with the response's own "${OUTCOME_KEY}" — the outcome picked. Rename it, e.g. id: '${OUTCOME_KEY}Value'.`);
+        }
+        if (!IDENTIFIER.test(f.id)) {
+            throw new Error(`${where}: form field "${f.id}" (${f.direction}) is not a name the runtime can read back as =${f.id}. ` +
+                `Use an identifier (letters, digits, _ or $), e.g. id: '${f.id.replace(/\W+(\w)?/g, (_m, c) => (c ?? '').toUpperCase())}'.`);
+        }
+        if (RESERVED_WORDS.has(f.id)) {
+            throw new Error(`${where}: form field "${f.id}" is a reserved word, which the runtime cannot bind as a name — it would lose every answer and the outcome. Rename it, e.g. id: '${f.id}Value'.`);
+        }
+        // The SDK's own spellings only. The product also resolves platform aliases such as
+        // `System.String`, but those are not `FormFieldType`s: accepting one here would let a
+        // decompile lift write source that does not type-check, so such an import stays verbatim.
+        if (!FORM_FIELD_TYPES.includes(String(f.type))) {
+            throw new Error(`${where}: form field "${f.id}" has type "${String(f.type)}". Valid: ${validFormFieldTypesText()}. ${formFieldTypeHint(f.type)}`.trimEnd());
+        }
+        // The checks Flow's form checker reports as errors: a picker the reviewer cannot
+        // pick from, and a setting the platform's schema refuses. (Options on a field that
+        // renders no picker is a warning there, and is not refused here.)
+        if (formFieldOptionsProblem(f) === 'missing') {
+            throw new Error(`${where}: form field "${f.id}" ${formFieldOptionsWhy('missing', f.type)}. Add options: [{ id: 'o1', value: 'a', label: 'A' }, …].`);
+        }
+        const settings = formFieldSettingProblems(f);
+        if (settings.length)
+            throw new Error(`${where}: form field "${f.id}" sets ${settings.join('; ')}.`);
+        if (isShown(f) && (typeof f.value !== 'string' || !f.value.startsWith('='))) {
+            throw new Error(`${where}: form field "${f.id}" (${f.direction}) needs a value — a =-expression such as '=vars.${f.id}' — or the form shows it empty.`);
+        }
+    }
+    // One variable, one writer. Two answers landing in one variable, or an `outputs`
+    // mapping onto an answer's variable, both evaluate and the LAST row wins, so an answer
+    // is lost with no signal (`outputs: { decision: '=Action' }` beside a field named
+    // `decision` replaces the reviewer's text with the outcome name). The product's own
+    // converter never writes that shape (`applyHitlExtension` dedupes with `seenVars`).
+    const writers = new Map();
+    const claim = (variable, writer) => {
+        const first = writers.get(variable);
+        if (first !== undefined) {
+            throw new Error(`${where}: ${first} and ${writer} both write vars.${variable}, so one would overwrite the other. Give one a different variable.`);
+        }
+        writers.set(variable, writer);
+    };
+    claim(input.outputVar ?? `${id}_processResponse`, 'the task response (outputVar)');
+    for (const f of form.fields)
+        if (isAnswer(f))
+            claim(f.variable ?? f.id, `form field "${f.id}"`);
+    for (const v of Object.keys(input.outputs ?? {}))
+        claim(v, `outputs.${v}`);
+    const names = new Set();
+    const outcomeIds = new Map();
+    form.outcomes.forEach((o, i) => {
+        const name = typeof o === 'string' ? o : o?.name;
+        if (typeof name !== 'string' || name.trim() === '')
+            throw new Error(`${where}: every outcome needs a name.`);
+        if (names.has(name))
+            throw new Error(`${where}: outcome "${name}" is listed twice.`);
+        names.add(name);
+        // The schema's outcome ids must be unique too, and two names can reach one: an
+        // explicit `id` repeated, or `Needs review` and `Needs-review`, which both derive
+        // `needs-review`.
+        const outcomeId = outcomeIdOf(o, i);
+        const clash = outcomeIds.get(outcomeId);
+        if (clash !== undefined) {
+            throw new Error(`${where}: outcomes "${clash}" and "${name}" both have the id "${outcomeId}". Give one an explicit, different id: { name: '${name}', id: '…' }.`);
+        }
+        outcomeIds.set(outcomeId, name);
+    });
+}
+/**
+ * The rows a quick human task is written as.
+ *
+ * @param id - The task's element id.
+ * @param processId - The process id, which the default `hitlSchemaId` is derived from.
+ * @param input - The form and the task options.
+ * @returns The context, payload and output rows, the input schema and the type version.
+ * @throws Error when the form is malformed — see {@link validate}.
+ */
+export function quickHumanTaskRows(id, processId, input) {
+    const { form } = input;
+    validate(id, input);
+    const schemaId = form.schemaId ?? stableSchemaId(processId, id);
+    const fields = form.fields.map((f) => {
+        const row = { id: f.id, label: f.label ?? f.id, type: wireFormFieldType(f.type), direction: f.direction };
+        if (isShown(f))
+            row.binding = bindingOf(f.value);
+        if (isAnswer(f)) {
+            row.variable = `vars.${f.variable ?? f.id}`;
+            if (typeof f.required === 'boolean')
+                row.required = f.required;
+        }
+        return { ...row, ...formFieldSettingsWire(f) };
+    });
+    const outcomes = form.outcomes.map((o, i) => ({
+        id: outcomeIdOf(o, i),
+        name: typeof o === 'string' ? o : o.name,
+        type: 'string',
+        isPrimary: i === 0,
+        action: 'Continue',
+    }));
+    const shown = form.fields.filter(isShown);
+    const bindings = Object.fromEntries(shown.map((f) => [f.id, bindingOf(f.value)]));
+    const contextRows = [
+        { name: 'hitlType', type: 'string', value: 'quick' },
+        { name: '__hitlFormSchema', type: 'json', body: { id: schemaId, fields, outcomes } },
+        { name: 'hitlSchemaId', type: 'string', value: schemaId },
+        ...(shown.length ? [{ name: '__hitlInputBindings', type: 'json', body: bindings }] : []),
+        { name: 'taskTitle', type: 'string', value: input.title ?? input.name ?? id },
+        ...(input.priority !== undefined ? [{ name: 'priority', type: 'string', value: input.priority }] : []),
+        ...(input.labels !== undefined ? [{ name: 'labels', type: 'string', value: input.labels }] : []),
+    ];
+    // What the form shows, as JSON Schema — the converter's `inputSchema`.
+    const properties = {};
+    const required = [];
+    for (const f of shown) {
+        properties[f.id] = { ...formFieldJsonSchema(f.type), title: f.label ?? f.id };
+        if (f.direction === 'inOut' && f.required === true)
+            required.push(f.id);
+    }
+    const inputSchema = { $schema: DRAFT_07, type: 'object', properties, ...(required.length ? { required } : {}) };
+    const inputRows = [
+        { name: 'HitlTaskArguments', type: 'json', target: 'bodyField', body: Object.fromEntries(shown.map((f) => [f.id, f.value])) },
+    ];
+    const fieldById = new Map(form.fields.map((f) => [f.id, f]));
+    const outputRows = [
+        { name: RESPONSE_ROW, type: 'Actions.HITL', var: input.outputVar ?? `${id}_processResponse` },
+        ...form.fields.filter(isAnswer).map((f) => {
+            const v = f.variable ?? f.id;
+            return { name: v, type: rowTypeOf(f.type), source: `=${f.id}`, var: v, custom: true };
+        }),
+    ];
+    const mappedOutputRows = Object.entries(input.outputs ?? {}).map(([v, source]) => {
+        // The fallback type: an answer's field type for `=<fieldId>`, `string` otherwise
+        // (`=Action`, the outcome NAME, is a string). A declared variable overrides it.
+        const field = /^=([A-Za-z_$][\w$]*)$/.exec(source)?.[1];
+        const f = field === undefined ? undefined : fieldById.get(field);
+        return { name: v, type: f ? rowTypeOf(f.type) : 'string', source, var: v };
+    });
+    return { typeVersion: QUICK_TYPE_VERSION, contextRows, inputSchema, inputRows, outputRows, mappedOutputRows };
+}
+/**
+ * Rows as comparable text: each row's own keys sorted (a row read from XML and a row
+ * built here need not list them in the same order), but every body as its exact TEXT.
+ * A body that parses to the same value with other whitespace or key order would compile
+ * back to different bytes, so it must not count as a match.
+ */
+function rowsText(rows) {
+    return JSON.stringify(rows.map((r) => {
+        const entries = Object.entries(r)
+            .filter(([, v]) => v !== undefined)
+            .map(([k, v]) => [k, k === 'body' || k === 'schema' ? textOf(v) : v]);
+        return Object.fromEntries(entries.sort(([a], [b]) => a.localeCompare(b)));
+    }));
+}
+/** A body as the text it is written as — a value is JSON-stringified, as the serializer does. */
+function textOf(body) {
+    return typeof body === 'string' ? body : JSON.stringify(body);
+}
+/** Parse a json body read from XML, or `undefined` when it is not JSON. */
+function bodyValue(body) {
+    if (typeof body !== 'string')
+        return body;
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Read a quick task back as `.humanTask({ form })` options — or `undefined` when its
+ * rows are anything but what those options compile to.
+ *
+ * Best effort by construction, and safe because of the last step: the lifted options
+ * are run through {@link quickHumanTaskRows} and the result must equal the node's rows,
+ * order and all. A Studio Web task (sidecar schema, `_schemaFileId`, no response row)
+ * fails that and stays the verbatim `.activity()` it was.
+ *
+ * @param node - The node's rows, as decompile read them.
+ * @param processId - The id the decompiled `bpmn(…)` call will carry.
+ * @param authoredVarType - The wire type of each variable the decompiled source will
+ * DECLARE with `.var()` — what the serializer types a mapped `outputs` row from on the
+ * way back. A variable decompile folds away is not one: its row is re-typed from the
+ * fallback, so it has to already carry that type to match.
+ * @returns The options, or `undefined` to keep the node verbatim.
+ */
+export function liftQuickHumanTask(node, processId, authoredVarType = () => undefined) {
+    const ctx = new Map(node.contextRows.map((r) => [r.name, r]));
+    if (ctx.get('hitlType')?.value !== 'quick')
+        return undefined;
+    const schema = bodyValue(ctx.get('__hitlFormSchema')?.body);
+    if (!schema || !Array.isArray(schema.fields) || !Array.isArray(schema.outcomes))
+        return undefined;
+    const args = bodyValue(node.inputRows.find((r) => r.name === 'HitlTaskArguments')?.body);
+    let lifted;
+    try {
+        const fields = schema.fields.map((row) => {
+            const id = String(row.id);
+            const base = {
+                id,
+                ...(row.label !== undefined && row.label !== id ? { label: String(row.label) } : {}),
+                type: row.type,
+                ...liftFormFieldSettings(row),
+            };
+            const variable = typeof row.variable === 'string' ? row.variable.replace(/^vars\./, '') : undefined;
+            const answerVar = variable !== undefined && variable !== id ? { variable } : {};
+            const required = typeof row.required === 'boolean' ? { required: row.required } : {};
+            if (row.direction === 'input')
+                return { ...base, direction: 'input', value: String(args?.[id]) };
+            if (row.direction === 'inOut')
+                return { ...base, direction: 'inOut', value: String(args?.[id]), ...required, ...answerVar };
+            return { ...base, direction: 'output', ...required, ...answerVar };
+        });
+        const outcomes = schema.outcomes.map((o, i) => {
+            const name = String(o.name);
+            return outcomeIdOf(name, i) === o.id ? name : { name, id: String(o.id) };
+        });
+        const schemaId = String(schema.id);
+        const response = node.outputRows[0];
+        const answerVars = new Set(fields.filter((f) => f.direction !== 'input').map((f) => f.variable ?? f.id));
+        const extra = node.outputRows.slice(1).filter((r) => r.var !== undefined && !answerVars.has(r.var) && !r.custom);
+        lifted = {
+            form: { fields, outcomes, ...(schemaId !== stableSchemaId(processId, node.id) ? { schemaId } : {}) },
+            ...(node.name !== undefined ? { name: node.name } : {}),
+            ...(ctx.get('taskTitle')?.value !== (node.name ?? node.id) ? { title: ctx.get('taskTitle')?.value } : {}),
+            ...(ctx.has('priority') ? { priority: ctx.get('priority').value } : {}),
+            ...(ctx.has('labels') ? { labels: ctx.get('labels').value } : {}),
+            ...(extra.length ? { outputs: Object.fromEntries(extra.map((r) => [r.var, r.source ?? ''])) } : {}),
+            ...(response?.var !== undefined && response.var !== `${node.id}_processResponse` ? { outputVar: response.var } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+    let rebuilt;
+    try {
+        rebuilt = quickHumanTaskRows(node.id, processId, lifted);
+    }
+    catch {
+        return undefined;
+    }
+    const same = (node.typeVersion ?? 'v1') === rebuilt.typeVersion &&
+        rowsText(node.contextRows) === rowsText(rebuilt.contextRows) &&
+        node.inputSchema !== undefined &&
+        textOf(node.inputSchema) === textOf(rebuilt.inputSchema) &&
+        rowsText(node.inputRows) === rowsText(rebuilt.inputRows) &&
+        rowsText(node.outputRows) ===
+            rowsText([
+                ...rebuilt.outputRows,
+                ...rebuilt.mappedOutputRows.map((r) => ({ ...r, type: (r.var !== undefined ? authoredVarType(r.var) : undefined) ?? r.type })),
+            ]);
+    return same ? lifted : undefined;
+}

package/dist/bpmn/serialize.js

@@ -470,6 +470,7 @@ function createNode(ctx, n) {
                 skipCondition: n.skipCondition,
                 contextVerbatim: n.contextVerbatim,
                 outputRows: n.outputRows,
+                mappedOutputRows: n.mappedOutputRows,
             }, (varId) => ctx.authoredVarType.get(varId)), n);
         case 'subProcess':
             return applyActivityFields(ctx, createSubProcess(ctx, n), n);
@@ -822,6 +823,13 @@ export function implicitNodeVars(nodes, declared) {
             // is what keeps a node's own outputs inside the node: 83 of the 112 declarations
             // in `claims-intake-hitl` are this shape, and every one of them had to be
             // restated as a `.var()` because the derivation could not reach the row.
+            // A mapped row's own type is its fallback, so an undeclared variable is declared
+            // as the row is written; a declared one keeps its own (`claim` skips it). First, so
+            // `typedNodeDeclaredVars` below, which lists them too, cannot claim them untyped.
+            for (const row of n.mappedOutputRows ?? []) {
+                const d = rowDeclaration(row);
+                claim(row.var, n.id, d.type, d);
+            }
             if (n.outputRows) {
                 for (const row of n.outputRows) {
                     const d = rowDeclaration(row);

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

@@ -376,6 +376,12 @@ export interface TypedNodeInput {
      * for a caller that already knows the exact rows.
      */
     outputRows?: TypedOutputRow[];
+    /**
+     * Rows written after everything else, each typed from the author-declared variable it
+     * writes (the `varType` callback), its own `type` otherwise. Unlike `outputs` these
+     * survive `outputRows`; `.humanTask({ form })` uses them for its `outputs`.
+     */
+    mappedOutputRows?: TypedOutputRow[];
     /** `=`-expression that skips the node when truthy (activity/event tags only). */
     skipCondition?: string;
     /**

package/dist/bpmn/typed-node.js

@@ -556,6 +556,7 @@ varType) {
         // TypedNodeInput.outputRows — this is what lets a connector's response schema
         // survive a round trip.
         rows.push(...verbatimOutputRows(m, input.outputRows));
+        rows.push(...mappedRows(m, input.mappedOutputRows, varType));
         if (rows.length)
             payload.output = rows;
         return finish(m, spec, id, input.name, payload);
@@ -588,10 +589,15 @@ varType) {
         // which is what every row did before.
         rows.push(m.create('uipath:Output', { name: varId, type: varType?.(varId) ?? 'string', source, var: varId }));
     }
+    rows.push(...mappedRows(m, input.mappedOutputRows, varType));
     if (rows.length)
         payload.output = rows;
     return finish(m, spec, id, input.name, payload);
 }
+/** `TypedNodeInput.mappedOutputRows`, each typed from its declared variable when there is one. */
+function mappedRows(m, rows, varType) {
+    return verbatimOutputRows(m, (rows ?? []).map((r) => ({ ...r, type: (r.var !== undefined ? varType?.(r.var) : undefined) ?? r.type })));
+}
 /** `uipath:Output` rows exactly as the caller spelled them, deriving nothing. */
 export function verbatimOutputRows(m, rows) {
     return rows.map((row) => {

package/dist/case/case-sdk.d.ts

@@ -1123,8 +1123,8 @@ declare class TaskBuilder {
         type?: TypeDesc;
     }>): this;
     /**
-     * Extract fields of the task's **result** into case variables (reference-mode
-     * tasks). Each key is the case-variable name a later task/condition reads as
+     * Extract fields of the task's **result** into case variables (reference-mode,
+     * connector and wait-for-connector tasks). Each key is the case-variable name a later task/condition reads as
      * `=vars.<name>`; each value is the source field expression (e.g. `=response`,
      * `=Error.Message`). Pass `{ source, type }` to set a non-string type. Emits a
      * `data.outputs[]` row plus a root `inputOutputs` companion so the name resolves.
@@ -1150,6 +1150,11 @@ declare class TaskBuilder {
      * later output's (`check` reports `OUTPUT_SELF_REFERENCE` /
      * `OUTPUT_FORWARD_READ`).
      *
+     * On a connector or wait-for-connector task, a field is read from the
+     * operation's (or event's) `response`: an SDD row `app_id -> postAppId` is
+     * `.outputs({ postAppId: '=response.app_id' })`. Each extract is written after
+     * the task's own `response` and `Error` rows.
+     *
      * @example
      * **Extract a result field and assign two custom outputs**
      * ```ts

package/dist/case/case-sdk.js

@@ -474,8 +474,8 @@ class TaskBuilder {
         return this;
     }
     /**
-     * Extract fields of the task's **result** into case variables (reference-mode
-     * tasks). Each key is the case-variable name a later task/condition reads as
+     * Extract fields of the task's **result** into case variables (reference-mode,
+     * connector and wait-for-connector tasks). Each key is the case-variable name a later task/condition reads as
      * `=vars.<name>`; each value is the source field expression (e.g. `=response`,
      * `=Error.Message`). Pass `{ source, type }` to set a non-string type. Emits a
      * `data.outputs[]` row plus a root `inputOutputs` companion so the name resolves.
@@ -501,6 +501,11 @@ class TaskBuilder {
      * later output's (`check` reports `OUTPUT_SELF_REFERENCE` /
      * `OUTPUT_FORWARD_READ`).
      *
+     * On a connector or wait-for-connector task, a field is read from the
+     * operation's (or event's) `response`: an SDD row `app_id -> postAppId` is
+     * `.outputs({ postAppId: '=response.app_id' })`. Each extract is written after
+     * the task's own `response` and `Error` rows.
+     *
      * @example
      * **Extract a result field and assign two custom outputs**
      * ```ts
@@ -549,13 +554,23 @@ class TaskBuilder {
     _build() {
         if (!this._kind)
             throw new Error(`task "${this._name}" has no kind — call .process()/.agent()/.rpa()/.action()/.connector()/.waitForTimer()/… once.`);
-        // Task I/O binding is reference-mode only (REF_IO). Connector tasks derive
-        // their own inputs/outputs from the operation schema.
+        // Task input binding is reference-mode only (REF_IO): a connector task takes
+        // its inputs in `.connector()` / `.waitForConnector()`. Output extracts also
+        // work on connector and wait-for-connector tasks: the task writes its own
+        // `response` and `Error` rows, and each extract (`=response.<field>`) is one
+        // more row after them, as `uip maestro case sdd convert` and `case splice`
+        // write an SDD row `app_id -> postAppId`.
         const REF_IO = new Set(['process', 'agent', 'rpa', 'api-workflow', 'case-management', 'flow-process', 'function', 'business-rule']);
-        if ((this._inputs || this._outputs) && !REF_IO.has(this._kind))
-            throw new Error(`task "${this._name}": .inputs()/.outputs() are only supported on reference-mode tasks (process/agent/rpa/api-workflow/case-management/flow-process/function/business-rule), not "${this._kind}".`);
-        if (!this._ref && (this._inputs || this._outputs))
+        const CONNECTOR_OUTPUTS = new Set(['connector', 'wait-for-connector']);
+        if (this._inputs && !REF_IO.has(this._kind))
+            throw new Error(`task "${this._name}": .inputs()/.outputs() are only supported on reference-mode tasks (process/agent/rpa/api-workflow/case-management/flow-process/function/business-rule), not "${this._kind}". A connector task takes its inputs in .connector() / .waitForConnector().`);
+        if (this._outputs && !REF_IO.has(this._kind) && !CONNECTOR_OUTPUTS.has(this._kind))
+            throw new Error(`task "${this._name}": .outputs() is only supported on reference-mode tasks (process/agent/rpa/api-workflow/case-management/flow-process/function/business-rule) and on connector / wait-for-connector tasks, not "${this._kind}".`);
+        if (REF_IO.has(this._kind) && !this._ref && (this._inputs || this._outputs))
             throw new Error(`task "${this._name}": an unresolved reference task cannot declare inputs or outputs.`);
+        if (this._kind === 'wait-for-connector' && this._outputs
+            && !(this._waitConnector && 'connector' in this._waitConnector && 'event' in this._waitConnector))
+            throw new Error(`task "${this._name}": a placeholder wait-for-connector task has no event response to extract outputs from — name the event (.waitForConnector(<trigger descriptor>) or { connector, event }).`);
         return {
             name: this._name,
             kind: this._kind,

package/dist/case/check.js

@@ -597,6 +597,20 @@ function checkStage(stage, diags, refStage, refPlacement, bindings) {
                     });
             }
         }
+        // A connector task's result is its `response` (and `Error`): `=app_id`
+        // names nothing at run time. The field is `=response.app_id`, the source
+        // `uip maestro case sdd convert` writes for the SDD row `app_id -> postAppId`.
+        if (t.kind === 'connector' || t.kind === 'wait-for-connector')
+            for (const o of t.outputs ?? [])
+                // A custom row (`{ assign }`, builder-sdk#1438) sets a variable from an
+                // expression, not from the response, so it is not an extract.
+                if (!o.custom && !/^=\s*(response|Error)(?=$|[.[])/.test(o.source))
+                    diags.push({
+                        level: 'error',
+                        code: 'CONNECTOR_OUTPUT_SOURCE',
+                        message: `${t.kind === 'connector' ? 'Connector' : 'Wait-for-connector'} task "${t.name}" output "${o.var}" reads "${o.source}". A connector task's result is its response: write "=response.${o.source.replace(/^=\s*/, '')}" (or "=Error.<field>" for the error).`,
+                        where: t.name,
+                    });
         if (t.kind === 'flow-process' && (!t.ref || !t.ref.name.trim()))
             diags.push({
                 level: 'error',

package/dist/case/decompile.js

@@ -782,6 +782,28 @@ function actionApp(data, refs, task) {
 function isAuthorableBusinessRule(task) {
     return task.type === 'business-rule' && task.data?.version === 'v3';
 }
+/** Task kinds whose own `response` / `Error` rows can be followed by `.outputs()` extracts. */
+const CONNECTOR_EXTRACT_KINDS = new Set(['execute-connector-activity', 'wait-for-connector']);
+/**
+ * A connector or wait-for-connector task's extract rows: every output but the
+ * `response` and `Error` rows `.connector()` / `.waitForConnector()` re-emit
+ * themselves. Dropping them lost every SDD extract on a round trip.
+ */
+function connectorExtracts(task) {
+    const rows = Array.isArray(task.data?.outputs) ? task.data.outputs : [];
+    return rows.filter((row) => !isConnectorOwnOutput(row));
+}
+/**
+ * A connector's own `response` / `Error` row, which the builder re-emits
+ * itself. Its id and source may carry a plan-wide suffix (`=response2`,
+ * builder-sdk#518), so the source is matched with the suffix, the same test
+ * the trigger path uses. An exact match made a suffixed own row look like an
+ * extract, which `check` then refused (CONNECTOR_OUTPUT_SOURCE).
+ */
+function isConnectorOwnOutput(row) {
+    return (row.name === 'response' && /^=response\d*$/.test(String(row.source ?? '')))
+        || (row.name === 'Error' && /^=Error\d*$/.test(String(row.source ?? '')));
+}
 /** The two outputs every business-rule task carries, which `.businessRule()` re-emits itself. */
 function isBusinessRuleOwnOutput(row) {
     return (row.name === 'output' && row.source === '=result') || (row.name === 'Error' && row.source === '=Error');
@@ -837,6 +859,11 @@ function emitTask(out, depth, task, lane, refs, library) {
         if (extracts.length)
             out.line(inner, `.outputs(${ioArg(extracts, 'outputs')})`);
     }
+    if (CONNECTOR_EXTRACT_KINDS.has(String(task.type))) {
+        const extracts = connectorExtracts(task);
+        if (extracts.length)
+            out.line(inner, `.outputs(${ioArg(extracts, 'outputs')})`);
+    }
     if (task.isRequired !== undefined)
         out.line(inner, task.isRequired ? '.required()' : '.required(false)');
     if (task.shouldRunOnlyOnce !== undefined)
@@ -921,8 +948,7 @@ function varSpec(entry) {
 function isResolvedConnectorOutput(row, triggerId, resolved) {
     if (!resolved || row.elementId !== triggerId)
         return false;
-    return (row.name === 'response' && /^=response\d*$/.test(String(row.source ?? '')))
-        || (row.name === 'Error' && /^=Error\d*$/.test(String(row.source ?? '')));
+    return isConnectorOwnOutput(row);
 }
 function producedVariableNames(plan) {
     const produced = new Set();
@@ -955,6 +981,12 @@ function producedVariableNames(plan) {
                         if (row.var && !isBusinessRuleOwnOutput(row))
                             produced.add(row.var);
                 }
+                else if (CONNECTOR_EXTRACT_KINDS.has(String(task.type))) {
+                    // A connector extract registers its case variable on recompile too.
+                    for (const row of connectorExtracts(task))
+                        if (row.var)
+                            produced.add(row.var);
+                }
             }
     }
     // An own-name row that carries `originalVar` (`{ id: 'estimatedAge', var:

package/dist/case/serialize.js

@@ -1002,7 +1002,7 @@ function taskData(task, resolver, taskId, stageId, ids) {
         // `task.elementId === output.elementId` filter matched none of them and the
         // task's `response` / `Error` never reached a later task (#1419).
         case 'connector':
-            return connectorTaskData(task.connector, resolver, `${stageId}-${taskId}`, `Connector task "${task.name}"`);
+            return withOutputExtracts(connectorTaskData(task.connector, resolver, `${stageId}-${taskId}`, `Connector task "${task.name}"`), task, ids, resolver);
         case 'external-agent':
         case 'external-workflow':
             return externalTaskData(task.kind, task.external, resolver, `${stageId}-${taskId}`, `${task.kind === 'external-agent' ? 'External Agent' : 'External Workflow'} task "${task.name}"`);
@@ -1018,9 +1018,33 @@ function taskData(task, resolver, taskId, stageId, ids) {
         case 'wait-for-connector':
             // Floor placeholder (no connector named) = `serviceType` only; naming the
             // connector/operation emits the `context` subscription.
-            return waitConnectorBag(task.waitConnector, { alwaysContext: false }, resolver, `${stageId}-${taskId}`, `Wait-for-connector task "${task.name}"`);
+            return withOutputExtracts(waitConnectorBag(task.waitConnector, { alwaysContext: false }, resolver, `${stageId}-${taskId}`, `Wait-for-connector task "${task.name}"`), task, ids, resolver);
     }
 }
+/**
+ * A connector or wait-for-connector task's `.outputs()` extracts, appended to
+ * the `response` / `Error` rows the task writes itself. Each is an ordinary task
+ * output (`emitTaskOutput`) on the same `elementId` as those rows, e.g. for
+ * `.outputs({ postAppId: '=response.app_id' })`:
+ *   { name: 'app_id', type: 'string', id: 'o…', var: 'postAppId', originalVar: 'o…',
+ *     value: 'postAppId', source: '=response.app_id', target: '=o…', elementId }
+ * That is the row `uip maestro case sdd convert` writes for the SDD row
+ * `app_id -> postAppId`, and `validate --strict --sdd` matches it on
+ * `source` + `var` (STRICT_SDD_EXTRACT_MISSING).
+ */
+function withOutputExtracts(data, task, ids, resolver) {
+    if (!task.outputs?.length)
+        return data;
+    const own = Array.isArray(data.outputs) ? data.outputs : [];
+    const elementId = own.find((row) => typeof row.elementId === 'string')?.elementId;
+    if (!elementId)
+        throw new Error(`task "${task.name}": output extracts need the task's resolved response output.`);
+    data.outputs = [
+        ...own,
+        ...task.outputs.map((o, i) => emitTaskOutput(o, elementId, ids, `${elementId}:out:${i}:${o.var}`, resolver)),
+    ];
+    return data;
+}
 /**
  * The `wait-for-connector` subscription bag (`data` on the task, `uipath` on the
  * rule). Verified against a real `uip maestro case` caseplan: a placeholder

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.54.1",
+  "version": "6.56.0",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -96,5 +96,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "5dfee12e621c69cfa2cf1338fc7df299768dbe16"
+  "gitref": "31230281aaf4fa5e44d2844c08747ead2814e94d"
 }