@uipath/maestro-builder-sdk 6.55.0 → 6.56.0

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

@@ -23,6 +23,8 @@ import type { TypeDesc } from '../core/expr.js';
 import { type ConnectorOpts, type EventFilter } from '../core/actions.js';
 import type { ConnectorDescriptor } from '../core/connectors.js';
 import type { RegistryTypeSpec, TypedContextRow, TypedInputRow, TypedOutputRow } from './typed-node.js';
+import { type HumanTaskForm } from './human-task-form.js';
+export type { HumanTaskForm, HumanTaskFormField, HumanTaskShownField, HumanTaskAskedField, HumanTaskInOutField, HumanTaskOutcome, } from './human-task-form.js';
 import { type DataServiceOperation } from './data-service.js';
 export type { DataServiceOperation } from './data-service.js';
 export { BpmnBuildError } from './bpmn-expr-check.js';
@@ -191,6 +193,12 @@ export type BpmnNode = {
     outputs?: Record<string, string>;
     /** Output rows spelled out, replacing the derived ones — see `TypedOutputRow`. */
     outputRows?: TypedOutputRow[];
+    /**
+     * Rows written AFTER `outputRows`, each typed from the AUTHOR-declared variable it
+     * writes when there is one, its own `type` otherwise — `.humanTask({ form })`'s
+     * `outputs`, which have to be typed like the app variant's.
+     */
+    mappedOutputRows?: TypedOutputRow[];
     /** The `uipath:type` `version` attribute — see `ActivityNodeOpts.typeVersion`. */
     typeVersion?: string;
     /** The `uipath:inputSchema` body — see `ActivityNodeOpts.inputSchema`. */
@@ -1355,19 +1363,41 @@ export interface QueueItemOpts extends ActivityOpts {
     /** `=`-expression that skips the enqueue when truthy. */
     skipCondition?: string;
 }
+/** What both variants of `.humanTask()` take. */
+export interface HumanTaskCommonOpts extends ActivityOpts {
+    /** Display name the designer shows on the task. */
+    name?: string;
+    /** The task title a human sees (`taskTitle`). */
+    title?: string;
+    /**
+     * Fields to pull out of the human's response into variables, e.g.
+     * `{ decision: '=Action' }`.
+     *
+     * Worth setting whenever a gateway branches on the outcome. The type's own
+     * output row is typed (`type="Actions.HITL"`, no `source`), which the designer
+     * resolves but the local runtime leaves `undefined` — so without a mapped field
+     * here, a local run cannot branch on the decision at all. `=Action` is the field
+     * the runtime's own outcome routing reads.
+     */
+    outputs?: Record<string, string>;
+    /** Variable the whole typed response lands in. Defaults to `<id>_processResponse`. */
+    outputVar?: string;
+    /** `=`-expression that skips the task when truthy. */
+    skipCondition?: string;
+}
 /**
- * Options for `.humanTask()` — an `Actions.HITL` action-app task.
+ * Options for `.humanTask()` backed by an Action App — an `Actions.HITL` action-app task.
  *
  * `app` is the Action App's id and the registry marks it the type's primary key,
  * so it comes from the tenant (`RequiresDiscovery: Yes`). Nothing offline can
  * resolve it: pass the id, or a `=bindings.<id>` reference so it is configurable
- * per environment.
+ * per environment. With no app on the tenant, use {@link HumanTaskFormOpts} instead.
  */
-export interface HumanTaskOpts extends ActivityOpts {
-    /** Display name the designer shows on the task. */
-    name?: string;
+export interface HumanTaskAppOpts extends HumanTaskCommonOpts {
     /** The Action App's id (`appId`). Tenant-specific — see the remarks above. */
     app: string;
+    /** Not on this variant — see {@link HumanTaskFormOpts}. */
+    form?: never;
     /** The app version (`appVersion`). */
     appVersion?: number;
     /**
@@ -1380,28 +1410,41 @@ export interface HumanTaskOpts extends ActivityOpts {
      * outcomes, this is the first thing to compare against a Studio Web export.
      */
     actions?: string[];
-    /** The task title a human sees (`taskTitle`). */
-    title?: string;
     /** An existing task key, when resuming rather than creating (`key`). */
     key?: string;
     /** Data the task shows the human — the node's `HitlTaskArguments`. */
     input?: Record<string, unknown>;
-    /**
-     * Fields to pull out of the human's response into variables, e.g.
-     * `{ decision: '=Action' }`.
-     *
-     * Worth setting whenever a gateway branches on the outcome. The type's own
-     * output row is typed (`type="Actions.HITL"`, no `source`), which the designer
-     * resolves but the local runtime leaves `undefined` — so without a mapped field
-     * here, a local run cannot branch on the decision at all. `=Action` is the field
-     * the runtime's own outcome routing reads.
-     */
-    outputs?: Record<string, string>;
-    /** Variable the whole typed response lands in. Defaults to `<id>_processResponse`. */
-    outputVar?: string;
-    /** `=`-expression that skips the task when truthy. */
-    skipCondition?: string;
 }
+/**
+ * Options for `.humanTask()` with an INLINE form — the quick-form `Actions.HITL` task,
+ * which needs no Action App.
+ *
+ * The default for a "a human reviews this" step whenever no deployed app is named: the
+ * form's fields and outcomes travel in the `.bpmn` itself (`hitlType=quick`, the
+ * `__hitlFormSchema` context row and its `hitlSchemaId`), the way the product's own
+ * Flow-to-BPMN converter writes a quick form. Each asked field's answer lands in its
+ * `variable` (default: its id); the outcome picked is `=Action`. See
+ * `human-task-form.ts` for why the form is inline rather than a `.hitl.json` sidecar.
+ *
+ * The engine takes this path only when the tenant has the `ShouldUseHitlQuickFormSchema`
+ * flag on; otherwise it falls back to the Action-App path, which has no app to open.
+ */
+export interface HumanTaskFormOpts extends HumanTaskCommonOpts {
+    /** The inline form: its fields and its outcomes. */
+    form: HumanTaskForm;
+    /** Not on this variant — the form replaces the app. */
+    app?: never;
+    /** Action Center priority, e.g. `'Medium'` (`priority`). */
+    priority?: string;
+    /** Action Center labels, comma-separated (`labels`). */
+    labels?: string;
+}
+/**
+ * Options for `.humanTask()` — an `Actions.HITL` task, backed by an Action App
+ * ({@link HumanTaskAppOpts}) or by an inline form ({@link HumanTaskFormOpts}).
+ * Exactly one of `app` and `form`.
+ */
+export type HumanTaskOpts = HumanTaskAppOpts | HumanTaskFormOpts;
 /**
  * Options for `.receiveMessage()` — `Maestro.ReceiveMessageEvent`.
  *
@@ -2007,6 +2050,14 @@ declare class SugarRegistry {
         vars: BpmnVarDecl[];
         elementId: string;
     }>;
+    /**
+     * The `bpmn(…)` id, which every scope can derive stable ids from — a quick human
+     * task's default `hitlSchemaId`. An explicit field rather than a parameter property,
+     * whose comment would not reach the emitted `.d.ts`.
+     */
+    readonly processId: string;
+    /** @param processId - The `bpmn(…)` id. */
+    constructor(processId?: string);
 }
 /**
  * Whether the node serializes to a start event — nothing may flow INTO it.
@@ -2666,10 +2717,16 @@ declare abstract class ScopeBuilder {
      */
     queueItem(id: string, opts: QueueItemOpts, body?: ActivityBodyFn): this;
     /**
-     * A **human task** — an Action App task a person completes (`bpmn:userTask` +
-     * `uipath:activity` / `Actions.HITL`).
+     * A **human task** — a task a person completes in Action Center (`bpmn:userTask` +
+     * `uipath:activity` / `Actions.HITL`), shown either as an inline form or by an Action App.
      *
      * @remarks
+     * **Pick the variant by whether an app is named.** With no deployed Action App named,
+     * use `form: { fields, outcomes }` ({@link HumanTaskFormOpts}): the form travels in the
+     * `.bpmn` and nothing on the tenant has to exist. Use `app` ({@link HumanTaskAppOpts})
+     * only when the request names a deployed app — an app id that is not on the tenant fails
+     * `uip maestro bpmn validate` with `MISSING_BINDING` / `MISSING_RESOURCE`.
+     *
      * The offline runtime can stand in for the human — `--hitl-response` injects an
      * outcome — so an approval gate's branches are testable with no tenant and no
      * waiting. That is why this is the one discovery-requiring type worth authoring
@@ -2680,7 +2737,7 @@ declare abstract class ScopeBuilder {
      * ```
      *
      * Map the decision into a variable with `outputs` if anything branches on it —
-     * see {@link HumanTaskOpts.outputs} for why the type's own output is not enough.
+     * see {@link HumanTaskCommonOpts.outputs} for why the type's own output is not enough.
      *
      * @example
      * **An approval gate whose branches can be exercised offline**
@@ -2710,9 +2767,35 @@ declare abstract class ScopeBuilder {
      *   .build();
      * ```
      *
+     * @example
+     * **A review fallback with an inline form — no Action App**
+     * ```ts
+     * bpmn('triage')
+     *   .var('category', 'string', { default: 'billing' })
+     *   .var('decision', 'string')
+     *   .startEvent('start')
+     *   .humanTask('review', {
+     *     name: 'Review the category',
+     *     form: {
+     *       fields: [
+     *         // Shown and correctable: pre-filled from vars.category, written back to it.
+     *         { id: 'category', type: 'string', direction: 'inOut', value: '=vars.category' },
+     *         // Asked: the answer lands in vars.reviewNote.
+     *         { id: 'note', type: 'string', direction: 'output', variable: 'reviewNote' },
+     *       ],
+     *       outcomes: ['Accept', 'Escalate'],
+     *     },
+     *     outputs: { decision: '=Action' },
+     *   })
+     *   .endEvent('done')
+     *   .sequenceFlow('start', 'review')
+     *   .sequenceFlow('review', 'done')
+     *   .build();
+     * ```
+     *
      * @param id - The element id, unique in the process and used by `sequenceFlow`.
-     * @param opts - The app, the outcomes offered, what the human sees, and which
-     * response fields to keep.
+     * @param opts - The inline form or the app, what the human sees, and which response
+     * fields to keep.
      * @param body - Boundary events attached to this activity, declared on the {@link ActivityBuilder} it receives.
      * @returns This builder, so calls chain.
      */

package/dist/bpmn/bpmn-sdk.js

@@ -4,6 +4,7 @@ import { BPMN_SCHEMA_VERSIONS } from './format-profile.js';
 import { schemaVersionRefusal } from '../schema-version.js';
 import { bindingRequiredFields, REGISTRY_GAPS, registryType } from './typed-node.js';
 import { resolveResourceKeyPattern } from './resource-key-pattern.js';
+import { quickHumanTaskRows } from './human-task-form.js';
 import { DATA_SERVICE_ACTIVITY_TYPE, DATA_SERVICE_CONNECTOR_KEY, dataServiceWire } from './data-service.js';
 import { MANAGED_HTTP_CONNECTION_NAME, MANAGED_HTTP_CONNECTOR_KEY, MANAGED_HTTP_FOLDER_NAME, MANAGED_HTTP_TYPE, managedHttpContext, managedHttpInputs, managedHttpOutputs, } from './managed-http.js';
 import { ownEntry } from '../core/own-entry.js';
@@ -27,6 +28,16 @@ class SugarRegistry {
     pinnedFlowIds = new Map();
     /** Variables an `errorVar` asked for — declared at build unless the author declared the id. */
     autoVars = [];
+    /**
+     * The `bpmn(…)` id, which every scope can derive stable ids from — a quick human
+     * task's default `hitlSchemaId`. An explicit field rather than a parameter property,
+     * whose comment would not reach the emitted `.d.ts`.
+     */
+    processId;
+    /** @param processId - The `bpmn(…)` id. */
+    constructor(processId = '') {
+        this.processId = processId;
+    }
 }
 const GATEWAY_NODE_KINDS = new Set(['exclusiveGateway', 'parallelGateway', 'inclusiveGateway', 'eventBasedGateway']);
 /**
@@ -1511,10 +1522,16 @@ class ScopeBuilder {
         }, body);
     }
     /**
-     * A **human task** — an Action App task a person completes (`bpmn:userTask` +
-     * `uipath:activity` / `Actions.HITL`).
+     * A **human task** — a task a person completes in Action Center (`bpmn:userTask` +
+     * `uipath:activity` / `Actions.HITL`), shown either as an inline form or by an Action App.
      *
      * @remarks
+     * **Pick the variant by whether an app is named.** With no deployed Action App named,
+     * use `form: { fields, outcomes }` ({@link HumanTaskFormOpts}): the form travels in the
+     * `.bpmn` and nothing on the tenant has to exist. Use `app` ({@link HumanTaskAppOpts})
+     * only when the request names a deployed app — an app id that is not on the tenant fails
+     * `uip maestro bpmn validate` with `MISSING_BINDING` / `MISSING_RESOURCE`.
+     *
      * The offline runtime can stand in for the human — `--hitl-response` injects an
      * outcome — so an approval gate's branches are testable with no tenant and no
      * waiting. That is why this is the one discovery-requiring type worth authoring
@@ -1525,7 +1542,7 @@ class ScopeBuilder {
      * ```
      *
      * Map the decision into a variable with `outputs` if anything branches on it —
-     * see {@link HumanTaskOpts.outputs} for why the type's own output is not enough.
+     * see {@link HumanTaskCommonOpts.outputs} for why the type's own output is not enough.
      *
      * @example
      * **An approval gate whose branches can be exercised offline**
@@ -1555,13 +1572,74 @@ class ScopeBuilder {
      *   .build();
      * ```
      *
+     * @example
+     * **A review fallback with an inline form — no Action App**
+     * ```ts
+     * bpmn('triage')
+     *   .var('category', 'string', { default: 'billing' })
+     *   .var('decision', 'string')
+     *   .startEvent('start')
+     *   .humanTask('review', {
+     *     name: 'Review the category',
+     *     form: {
+     *       fields: [
+     *         // Shown and correctable: pre-filled from vars.category, written back to it.
+     *         { id: 'category', type: 'string', direction: 'inOut', value: '=vars.category' },
+     *         // Asked: the answer lands in vars.reviewNote.
+     *         { id: 'note', type: 'string', direction: 'output', variable: 'reviewNote' },
+     *       ],
+     *       outcomes: ['Accept', 'Escalate'],
+     *     },
+     *     outputs: { decision: '=Action' },
+     *   })
+     *   .endEvent('done')
+     *   .sequenceFlow('start', 'review')
+     *   .sequenceFlow('review', 'done')
+     *   .build();
+     * ```
+     *
      * @param id - The element id, unique in the process and used by `sequenceFlow`.
-     * @param opts - The app, the outcomes offered, what the human sees, and which
-     * response fields to keep.
+     * @param opts - The inline form or the app, what the human sees, and which response
+     * fields to keep.
      * @param body - Boundary events attached to this activity, declared on the {@link ActivityBuilder} it receives.
      * @returns This builder, so calls chain.
      */
     humanTask(id, opts, body) {
+        const hasApp = opts.app !== undefined;
+        const hasForm = opts.form !== undefined;
+        if (hasApp === hasForm) {
+            throw new Error(`humanTask "${id}": pass exactly one of app (a deployed Action App) or form ({ fields, outcomes }, an inline form that needs no app).`);
+        }
+        if (hasForm) {
+            const o = opts;
+            // The app variant's fields have no meaning on an inline form: the form IS the
+            // outcomes (`actions`) and what the human sees (`input`).
+            const appOnly = ['appVersion', 'actions', 'key', 'input'].filter((k) => opts[k] !== undefined);
+            if (appOnly.length) {
+                throw new Error(`humanTask "${id}": ${appOnly.join(', ')} belong to an app-backed task. On an inline form, put the outcomes in form.outcomes and what the human sees in form.fields.`);
+            }
+            const rows = quickHumanTaskRows(id, this._sugar.processId, o);
+            return this.pushActivity({
+                kind: 'typed',
+                id,
+                name: o.name,
+                type: 'Actions.HITL',
+                typeVersion: rows.typeVersion,
+                context: {},
+                contextRows: rows.contextRows,
+                inputSchema: rows.inputSchema,
+                inputs: {},
+                inputRows: rows.inputRows,
+                outputRows: rows.outputRows,
+                mappedOutputRows: rows.mappedOutputRows,
+                skipCondition: o.skipCondition,
+                tags: o.tags,
+                retry: o.retry,
+                errorMapping: o.errorMapping,
+                loop: o.loop,
+            }, body);
+        }
+        opts = opts;
         return this.pushActivity({
             kind: 'typed',
             id,
@@ -2612,7 +2690,7 @@ export class BpmnBuilder extends ScopeBuilder {
      * @returns The top-level builder.
      */
     constructor(_id) {
-        super(new DefinitionsRegistry(), new BindingsRegistry());
+        super(new DefinitionsRegistry(), new BindingsRegistry(), undefined, 'explicit', new SugarRegistry(_id));
         this._id = _id;
     }
     /**

package/dist/bpmn/declared-vars.js

@@ -35,10 +35,11 @@ export function connectorOutputVars(n) {
  */
 export function typedNodeDeclaredVars(n) {
     // Spelled-out rows REPLACE the derived pair, so they are the whole answer.
+    const mapped = (n.mappedOutputRows ?? []).map((r) => r.var).filter((v) => v !== undefined);
     if (n.outputRows)
-        return n.outputRows.map((r) => r.var).filter((v) => v !== undefined);
+        return [...n.outputRows.map((r) => r.var).filter((v) => v !== undefined), ...mapped];
     const v = typedNodeOutputVar(n.id, n.type, n.outputVar, n.spec);
-    return [...(v ? [v] : []), ...typedNodeAdditionalOutputVars(n.id, n.type, n.spec), ...Object.keys(n.outputs ?? {})];
+    return [...(v ? [v] : []), ...typedNodeAdditionalOutputVars(n.id, n.type, n.spec), ...Object.keys(n.outputs ?? {}), ...mapped];
 }
 /**
  * Every variable name a node DECLARES by writing to it — the platform counts a

package/dist/bpmn/decompile.js

@@ -62,6 +62,7 @@ import { preserveSchemaVersion } from '../schema-version.js';
 import { commentText } from '../core/comment-text.js';
 import { tsLiteral, tsText } from '../core/ts-literal.js';
 import { defaultEntryPointId } from './entry-point-id.js';
+import { liftQuickHumanTask } from './human-task-form.js';
 const require = createRequire(import.meta.url);
 const uipathDescriptor = require('./uipath-moddle.v1.json');
 /**
@@ -79,6 +80,12 @@ let pinExplicitInBodies = false;
  * business carrying a document-wide table.
  */
 let foldedVarSchemas;
+/**
+ * The wire type of each ROOT variable the source writes as a `.var()` — every declared one
+ * the derivation does not fold away. What `serialize` types a quick human task's mapped
+ * `outputs` rows from on the way back, so the lift compares against the same thing.
+ */
+let authoredVarTypes;
 // ─── Source emitters ──────────────────────────────────────────────────────────
 /**
  * Schema bodies that need no declaration, because the platform defines them.
@@ -759,6 +766,59 @@ function entryPointText(startId, value) {
         return 'false';
     return value === defaultEntryPointId(runEntryPoints.builderProcessId, startId) ? undefined : tsText(value);
 }
+/**
+ * A quick (inline-form) human task, written back as `.humanTask({ form })` — when the
+ * form options reproduce the node's rows exactly, which `liftQuickHumanTask` checks by
+ * compiling them. Anything else (a Studio Web task with a `.hitl.json` sidecar, an
+ * app-backed task) returns `false` and stays the verbatim `.activity()` below.
+ *
+ * So does a task whose output variable had its declaration folded onto the row with a
+ * schema body (`foldedVarSchemas`): the row carries that schema as `varSchema`, which
+ * `.humanTask()` has no option for, and the lift would drop it.
+ *
+ * @returns Whether the node was written.
+ */
+function emitQuickHumanTask(chain, el, payload) {
+    if ((payload.output ?? []).some((r) => r.var !== undefined && foldedVarSchemas?.has(r.var)))
+        return false;
+    const defined = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined));
+    const lifted = liftQuickHumanTask({
+        id: el.id,
+        name: el.name,
+        typeVersion: payload.type?.version,
+        contextRows: (payload.context?.input ?? []).map((r) => defined({ name: r.name, type: r.type, value: r.value, body: r.body, target: r.target, required: r.required })),
+        inputSchema: payload.context?.inputSchema?.body,
+        inputRows: (payload.input ?? []).map((r) => defined({ name: r.name, type: r.type, target: r.target, value: r.value, body: r.body })),
+        outputRows: (payload.output ?? []).map((r) => defined({
+            name: r.name,
+            type: r.type,
+            var: r.var,
+            source: r.source,
+            custom: r.custom === true || r.custom === 'true' ? true : undefined,
+            description: r.description,
+            target: r.target,
+            schema: r.body,
+        })),
+    }, runEntryPoints.builderProcessId, (varId) => authoredVarTypes?.get(varId));
+    if (!lifted)
+        return false;
+    const { form, ...rest } = lifted;
+    chain.add(`.humanTask(${tsText(el.id)}, ${opts([
+        ['name', rest.name !== undefined ? tsText(rest.name) : undefined],
+        ['title', rest.title !== undefined ? tsText(rest.title) : undefined],
+        ['form', tsLiteral(form)],
+        ['priority', rest.priority !== undefined ? tsText(rest.priority) : undefined],
+        ['labels', rest.labels !== undefined ? tsText(rest.labels) : undefined],
+        ['outputs', record(rest.outputs)],
+        ['outputVar', rest.outputVar !== undefined ? tsText(rest.outputVar) : undefined],
+        ['skipCondition', payload.skipCondition !== undefined ? tsText(payload.skipCondition) : undefined],
+        ['tags', tagsOf(el)],
+        ['retry', emitRetry(retryOf(el))],
+        ['errorMapping', emitErrorMapping(errorMappingOf(el))],
+        ['loop', emitLoop(el)],
+    ])})`);
+    return true;
+}
 /**
  * A registry-typed node.
  *
@@ -771,6 +831,8 @@ function entryPointText(startId, value) {
 function emitTypedNode(chain, el, payload, type) {
     const spec = registryType(type);
     const id = el.id;
+    if (type === 'Actions.HITL' && emitQuickHumanTask(chain, el, payload))
+        return;
     // Verbatim: reproduce every context field, in document order, and let the
     // emitter inject nothing. Stripping the ones that match a registry default
     // would be smaller source but a lossy round-trip — the artifact's own emitter
@@ -2241,6 +2303,9 @@ export async function decompile(xml, options = {}) {
     // `.schema()` plan when the document repeats it, inline when it does not — so
     // folding a declaration onto its row does not un-share a schema 27 nodes use.
     foldedVarSchemas = new Map([...folds].map(([id, body]) => [id, schemaPlan.ref.get(String(body)) ?? jsonLiteral(body)]));
+    authoredVarTypes = new Map([...(varsExt?.input ?? []), ...(varsExt?.inputOutput ?? []), ...(varsExt?.output ?? [])]
+        .filter((v) => !derived.has(v.id))
+        .map((v) => [String(v.id), String(v.type)]));
     // A folded declaration is not written as a `.var()`, so its POSITION in the block
     // would be lost — derived declarations are appended after the declared ones, and the
     // designer's order is not recoverable from anything else (it follows the owning
@@ -2275,6 +2340,7 @@ export async function decompile(xml, options = {}) {
     }
     finally {
         foldedVarSchemas = undefined;
+        authoredVarTypes = undefined;
         runLibrary = undefined;
     }
     const importFrom = options.importSpecifier ?? './bpmn-sdk.js';

package/dist/bpmn/human-task-form.d.ts

@@ -0,0 +1,170 @@
+/**
+ * human-task-form — the inline-form ("quick") `Actions.HITL` task, as rows.
+ *
+ * `.humanTask({ form })` and decompile's lift of a quick task both go through
+ * {@link quickHumanTaskRows}, so the rows an author's call compiles to and the rows a
+ * lift is checked against cannot drift apart: decompile writes `.humanTask({ form })`
+ * only when this function, fed the lifted options, reproduces the file's rows exactly.
+ *
+ * **The wire shape is the product's own Flow-to-BPMN converter's** (`applyHitlExtension`
+ * in `PO.Frontend`, vendored as `local-engine/vendor/flow-to-bpmn.mjs`), not Studio Web's
+ * BPMN designer's. Both reach the same engine path, and the difference is where the form
+ * lives:
+ *
+ * - The converter puts it INLINE, in a `__hitlFormSchema` context row. The engine's
+ *   `TemporalBpmnExecutor.TryResolveInlineSchema` reads that first, in every mode.
+ * - Studio Web writes a `<Label>.hitl.json` beside the process plus a `_schemaFileId`
+ *   context row. The engine finds the file in the package by its `schemaId`, and
+ *   `_schemaFileId` is a server-assigned designer pointer the engine never reads — so an
+ *   offline author can only ever write a placeholder there.
+ *
+ * Inline keeps the whole task in the `.bpmn`, needs no second output file, and is the
+ * shape the local engine already runs (`local-engine/src/hitl.ts`). What it gives up is
+ * Studio Web's "Edit Schema" canvas, which looks for the sidecar.
+ *
+ * Either way, the engine takes the quick path only when its `ShouldUseHitlQuickFormSchema`
+ * flag is on for the tenant (`HumanInTheLoopActivities`); otherwise it falls back to the
+ * Action-App path, which has no app to open.
+ */
+import type { FormFieldSettings, FormFieldType } from '../core/actions.js';
+import type { TypedContextRow, TypedInputRow, TypedOutputRow } from './typed-node.js';
+/** A value the reviewer READS: shown on the form, filled in from the process. */
+export interface HumanTaskShownField extends FormFieldSettings {
+    /** Field id — the key the form and its answers use. Must be unique on the form. */
+    id: string;
+    /** Label the reviewer sees. Defaults to `id`. */
+    label?: string;
+    /** The field's data type, e.g. `'string'` or `'number'` — the quick-form vocabulary Flow's forms use. */
+    type: FormFieldType;
+    direction: 'input';
+    /**
+     * What to show — a `=`-expression, e.g. `'=vars.amount'` or `'=js:vars.total * 1.2'`.
+     * Required: a shown field with nothing bound renders empty.
+     */
+    value: string;
+}
+/** A value the reviewer FILLS IN, landing in a process variable. */
+export interface HumanTaskAskedField extends FormFieldSettings {
+    /** Field id — the key the form and its answers use. Must be unique on the form. */
+    id: string;
+    /** Label the reviewer sees. Defaults to `id`. */
+    label?: string;
+    /** The field's data type, e.g. `'string'` or `'number'` — the quick-form vocabulary Flow's forms use. */
+    type: FormFieldType;
+    direction: 'output';
+    /** Reviewer must fill it in before the task can be completed. */
+    required?: boolean;
+    /** The process variable the answer lands in. Defaults to the field id. */
+    variable?: string;
+}
+/** A value the reviewer READS AND CAN CORRECT: pre-filled, editable, and written back. */
+export interface HumanTaskInOutField extends FormFieldSettings {
+    /** Field id — the key the form and its answers use. Must be unique on the form. */
+    id: string;
+    /** Label the reviewer sees. Defaults to `id`. */
+    label?: string;
+    /** The field's data type, e.g. `'string'` or `'number'` — the quick-form vocabulary Flow's forms use. */
+    type: FormFieldType;
+    direction: 'inOut';
+    /** What to pre-fill — a `=`-expression, e.g. `'=vars.category'`. */
+    value: string;
+    /** Reviewer must confirm or fill it before the task can be completed. */
+    required?: boolean;
+    /** The process variable the (possibly corrected) value lands in. Defaults to the field id. */
+    variable?: string;
+}
+/** One field of an inline human-task form. */
+export type HumanTaskFormField = HumanTaskShownField | HumanTaskAskedField | HumanTaskInOutField;
+/** One button the reviewer can finish the task with. */
+export type HumanTaskOutcome = string | {
+    name: string;
+    id?: string;
+};
+/** An inline form — the quick-form variant of `.humanTask()`, which needs no Action App. */
+export interface HumanTaskForm {
+    /** The fields, in the order the form shows them. */
+    fields: HumanTaskFormField[];
+    /**
+     * The buttons that finish the task, e.g. `['Approve', 'Reject']`. The one picked is
+     * the response's `Action` — map it with `outputs: { decision: '=Action' }`.
+     */
+    outcomes: HumanTaskOutcome[];
+    /**
+     * The form's `hitlSchemaId`, which Action Center caches the form under.
+     *
+     * Defaults to a v5 UUID derived from the process and task ids, so a rebuild is the
+     * same form and the same bytes. Set it only to keep an imported task's id.
+     */
+    schemaId?: string;
+}
+/** What `.humanTask({ form })` takes besides the form — the fields it shares with the app variant. */
+export interface QuickHumanTaskInput {
+    form: HumanTaskForm;
+    /** The task title (`taskTitle`). Defaults to the task's `name`, else its id. */
+    title?: string;
+    /** Display name of the task. */
+    name?: string;
+    /** Action Center priority, e.g. `'Medium'`. */
+    priority?: string;
+    /** Action Center labels, comma-separated. */
+    labels?: string;
+    /** Extra output rows: variable id → `=`-expression against the response, e.g. `{ decision: '=Action' }`. */
+    outputs?: Record<string, string>;
+    /** Variable the whole typed response lands in. Defaults to `<id>_processResponse`. */
+    outputVar?: string;
+}
+/** The rows a quick human task is written as. */
+export interface QuickHumanTaskRows {
+    typeVersion: string;
+    contextRows: TypedContextRow[];
+    inputSchema: Record<string, unknown>;
+    inputRows: TypedInputRow[];
+    outputRows: TypedOutputRow[];
+    /**
+     * The author's `outputs` mappings, written after `outputRows`. Each row's `type` is
+     * only the FALLBACK: the serializer types the row from the variable it writes when the
+     * author declared that variable (`.var('approved', 'boolean')`), as the app variant's
+     * `outputs` are typed — and from the answer field it reads, or `string`, otherwise.
+     */
+    mappedOutputRows: TypedOutputRow[];
+}
+/**
+ * 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 declare function quickHumanTaskRows(id: string, processId: string, input: QuickHumanTaskInput): QuickHumanTaskRows;
+/** The parts of a typed `Actions.HITL` node decompile reads a quick task back from. */
+export interface QuickHumanTaskSource {
+    id: string;
+    name?: string;
+    typeVersion?: string;
+    contextRows: TypedContextRow[];
+    inputSchema?: unknown;
+    inputRows: TypedInputRow[];
+    outputRows: TypedOutputRow[];
+}
+/** A lifted quick task: the `.humanTask()` options that reproduce it. */
+export type LiftedQuickHumanTask = QuickHumanTaskInput;
+/**
+ * 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 declare function liftQuickHumanTask(node: QuickHumanTaskSource, processId: string, authoredVarType?: (varId: string) => string | undefined): LiftedQuickHumanTask | undefined;