@uipath/maestro-builder-sdk 6.66.0 → 6.66.2

package/dist/core/process-resource.d.ts

@@ -80,7 +80,12 @@ export declare function processResourceLocation(spec: {
 export declare function processResourceBindings(spec: {
     name: string;
     folderPath: string;
-    resourceSubType: ProcessResourceSubType;
+    /**
+     * The binding's resource kind. `'process'` (the default) for a process
+     * reference; `'app'` for an Action App, which carries no subtype.
+     */
+    resource?: 'process' | 'app';
+    resourceSubType?: ProcessResourceSubType;
     resourceKey?: string;
 }, existing: ReadonlyMap<string, any>): {
     ids: {

package/dist/core/process-resource.js

@@ -63,8 +63,9 @@ export function processResourceLocation(spec) {
  * process share one pair.
  */
 export function processResourceBindings(spec, existing) {
+    const resource = spec.resource ?? 'process';
     const resourceKey = spec.resourceKey ?? `${spec.folderPath}.${spec.name}`;
-    const found = (attr) => [...existing.values()].find((b) => b.resource === 'process' && b.resourceKey === resourceKey && b.propertyAttribute === attr)?.id;
+    const found = (attr) => [...existing.values()].find((b) => b.resource === resource && b.resourceKey === resourceKey && b.propertyAttribute === attr)?.id;
     const already = { name: found('name'), folderPath: found('folderPath') };
     if (already.name && already.folderPath) {
         return { ids: { name: already.name, folderPath: already.folderPath }, entries: [] };
@@ -72,7 +73,7 @@ export function processResourceBindings(spec, existing) {
     // A readable, stable id per process. Two processes sharing a NAME across folders
     // would collide, so the id is suffixed until it is free — the queue emitter's
     // shape, which this is a port of.
-    const slug = spec.name.replace(/[^A-Za-z0-9]/g, '') || 'Process';
+    const slug = spec.name.replace(/[^A-Za-z0-9]/g, '') || (resource === 'app' ? 'App' : 'Process');
     let base = `b${slug.charAt(0).toUpperCase()}${slug.slice(1)}`;
     for (let n = 2; existing.has(`${base}Name`) || existing.has(`${base}FolderPath`); n++) {
         base = `b${slug.charAt(0).toUpperCase()}${slug.slice(1)}${n}`;
@@ -83,21 +84,21 @@ export function processResourceBindings(spec, existing) {
                 id: ids.name,
                 name: 'name',
                 type: 'string',
-                resource: 'process',
+                resource,
                 resourceKey,
                 default: spec.name,
                 propertyAttribute: 'name',
-                resourceSubType: spec.resourceSubType,
+                ...(spec.resourceSubType !== undefined ? { resourceSubType: spec.resourceSubType } : {}),
             },
             {
                 id: ids.folderPath,
                 name: 'folderPath',
                 type: 'string',
-                resource: 'process',
+                resource,
                 resourceKey,
                 default: spec.folderPath,
                 propertyAttribute: 'folderPath',
-                resourceSubType: spec.resourceSubType,
+                ...(spec.resourceSubType !== undefined ? { resourceSubType: spec.resourceSubType } : {}),
             },
         ] };
 }

package/dist/core/refusals.d.ts

@@ -306,6 +306,7 @@ export declare const REFUSALS: {
     readonly HITL_APP_INCOMPLETE: "lint";
     readonly HITL_APP_INPUT_REQUIRED: "lint";
     readonly HITL_APP_INPUT_UNKNOWN: "lint";
+    readonly HITL_APP_LOCAL_HAS_FOLDER: "lint";
     readonly HITL_APP_MISSING: "lint";
     readonly HITL_APP_NO_SCHEMA: "lint";
     readonly HITL_APP_OUTCOME_UNKNOWN: "lint";

package/dist/core/refusals.js

@@ -347,6 +347,7 @@ export const REFUSALS = {
     HITL_APP_INCOMPLETE: 'lint',
     HITL_APP_INPUT_REQUIRED: 'lint',
     HITL_APP_INPUT_UNKNOWN: 'lint',
+    HITL_APP_LOCAL_HAS_FOLDER: 'lint',
     HITL_APP_MISSING: 'lint',
     HITL_APP_NO_SCHEMA: 'lint',
     HITL_APP_OUTCOME_UNKNOWN: 'lint',

package/dist/merge.js

@@ -454,6 +454,7 @@ function mergeFlowFindings(original, edited, options) {
     //    not carried (#1133). ──
     result.bindings = mergeBindings(original.bindings, edited.bindings);
     result.bindings = withoutRowsMintedForKeptNodes(result.bindings, original, edited, options.baseline, keptFromOriginal, fieldwise);
+    result.bindings = withoutSupersededAppRows(result.bindings, originalNodes, allNodes);
     // metadata / solutionId / projectId / layout / runtime were carried by the
     // initial clone of `original` and are intentionally left untouched, apart
     // from the `layout.nodes` entries of removed nodes (dropped above) and added
@@ -667,6 +668,36 @@ function mergeBindings(orig, edited) {
     }
     return out;
 }
+/**
+ * The `app` rows a human task's app resolves through: keyed by the app's `key`
+ * once it has a folder, by its `name` while it has none — flow-v1's rule
+ * (`hitl-serialization.ts`, #3910), and `appResourceBindings`'.
+ */
+function appRowKey(node) {
+    const app = node.inputs?.app;
+    if (!app || typeof app !== 'object')
+        return undefined;
+    const k = app.folderPath ? app.key : app.name;
+    return typeof k === 'string' && k !== '' ? k : undefined;
+}
+/**
+ * Drop the original's `app` rows that a human task's app resolved through and
+ * that no merged node resolves through any more. That happens when the edit
+ * moves an app between the two keys — the canvas's `'solution_folder'` folder
+ * (keyed by `key`) re-emitted as an in-solution app (folder `''`, keyed by
+ * `name`): the edit brings the new pair, and the union would keep the old one
+ * beside it, orphaned (builder-sdk#1486 review). Rows no original human task
+ * used (an agent escalation's, say) are not touched.
+ */
+function withoutSupersededAppRows(rows, originalNodes, mergedNodes) {
+    if (!rows)
+        return rows;
+    const keysOf = (nodes) => new Set(nodes.map(appRowKey).filter((k) => k !== undefined));
+    const before = keysOf(originalNodes);
+    const after = keysOf(mergedNodes);
+    return rows.filter((b) => !(b.resource === 'app' && typeof b.resourceKey === 'string'
+        && before.has(b.resourceKey) && !after.has(b.resourceKey)));
+}
 /**
  * Drop each added row that the no-edit recompile minted only for nodes the merge
  * kept from the original (#1133). A row qualifies when the original lacks it, the

package/dist/nodes/hitl/flow/check.js

@@ -25,6 +25,7 @@ export const HITL_DIAGNOSTICS = {
     HITL_APP_INPUT_UNKNOWN: { severity: 'error', summary: 'an app input the action schema does not declare' },
     HITL_APP_INPUT_REQUIRED: { severity: 'error', summary: 'a required app input left unbound' },
     HITL_APP_OUTCOME_UNKNOWN: { severity: 'error', summary: 'an outcome the app has no button for' },
+    HITL_APP_LOCAL_HAS_FOLDER: { severity: 'error', summary: 'an in-solution app with a folderPath' },
     HITL_NO_FIELDS: { severity: 'error', summary: 'no fields array' },
     HITL_FIELD_NO_ID: { severity: 'error', summary: 'a form field with no id' },
     HITL_DUP_FIELD: { severity: 'error', summary: 'a form field id declared twice' },
@@ -185,11 +186,23 @@ export function checkHitl(inputs, ctx) {
                 + `App — but names no app, so nothing tells the platform which form to show.`, `app: { name: 'Expense Review', key: '<guid>', folderPath: 'Shared' }`);
             return;
         }
-        for (const k of ['name', 'key', 'folderPath']) {
+        // An in-solution app has no folder to author. A published one does: with
+        // none it is serialized as an inline app, and on a serializer before
+        // flow-v1 #4076 the task loses its folderPath context and fails at run
+        // time (170004, "Invalid input for the HITL task").
+        const inSolution = app.location === 'in-solution';
+        for (const k of inSolution ? ['name', 'key'] : ['name', 'key', 'folderPath']) {
             if (typeof app[k] !== 'string' || !app[k].trim()) {
-                at('HITL_APP_INCOMPLETE', `Human task "${step}" names an Action App with no ${k}. An app is resolved by its key plus `
-                    + `the folder it is deployed in, with the name shown to the reviewer — all three are needed `
-                    + `for the platform to find it.`, `app: { name: 'Expense Review', key: '<guid>', folderPath: 'Shared' }`);
+                at('HITL_APP_INCOMPLETE', inSolution
+                    ? `Human task "${step}" names an in-solution Action App with no ${k}. An in-solution app is `
+                        + `resolved by its key (\`resource.key\` in resources/solution_folder/app/codedAction/<App>.json), `
+                        + `with the name shown to the reviewer — both are needed for the platform to find it.`
+                    : `Human task "${step}" names an Action App with no ${k}. An app is resolved by its key plus `
+                        + `the folder it is deployed in, with the name shown to the reviewer — all three are needed `
+                        + `for the platform to find it. If the app is in the same solution as the flow, set `
+                        + `\`location: 'in-solution'\` instead of a folder.`, inSolution
+                    ? `app: { name: 'InvoiceReview', key: '<resource.key>', location: 'in-solution' }`
+                    : `app: { name: 'Expense Review', key: '<guid>', folderPath: 'Shared' }`);
                 return;
             }
         }
@@ -235,6 +248,12 @@ export function checkHitl(inputs, ctx) {
                 }
             }
         }
+        if (inSolution && app.folderPath !== undefined && app.folderPath !== '') {
+            at('HITL_APP_LOCAL_HAS_FOLDER', `Human task "${step}" names an in-solution Action App with folderPath ${JSON.stringify(app.folderPath)}. `
+                + `An in-solution app has no folder — it is emitted with the empty folder the platform's app picker `
+                + `writes for an app inline to the solution — so the value would be dropped. Remove it, or drop `
+                + `\`location: 'in-solution'\` to call an app published to that folder.`, `Delete \`folderPath\`.`);
+        }
         // Outcomes still matter for an app task: the flow's own routing and its
         // `Action`/`status` outputs are derived from them, so fall through to the
         // outcome rules below rather than returning here.

package/dist/nodes/hitl/flow/node-type.js

@@ -22,6 +22,7 @@ import { wireExprBody } from '../../../core/wire-expr.js';
 import { appAnswerSchemas, appInputSchema, liftActionSchema, normalizeActionSchema } from './action-schema.js';
 import { checkHitl, checkHitlRead } from './check.js';
 import { CompileRefusal } from '../../../core/compile-refusal.js';
+import { processResourceBindings } from '../../../core/process-resource.js';
 const BASE = 'uipath.human-in-the-loop';
 const QUICK_FORM = 'uipath.human-in-the-loop.quick-form';
 const ACTION_APP = 'uipath.human-in-the-loop.coded-action-app';
@@ -131,6 +132,14 @@ function hitlInputs(inputs, nodeType, ctx) {
     for (const [name, value] of Object.entries(app?.inputs ?? {})) {
         appInputBindings[name] = appBindingExpr(value, ctx);
     }
+    const emitsApp = (isApp || (nodeType === DOC_VALIDATION && inputs?.document?.render === 'custom')) && app !== undefined;
+    // An in-solution app has no folder: the platform's own picker writes `''`,
+    // and its serializer keeps that `''` in the task context (flow-v1 #4076).
+    const appFolder = app?.location === 'in-solution' ? '' : (app?.folderPath ?? '');
+    if (emitsApp) {
+        for (const b of appResourceBindings({ name: app.name, key: app.key, folderPath: appFolder }, ctx.bindings))
+            ctx.bind(b);
+    }
     // The author's recipient when given; the definition's own default otherwise
     // (unchanged — that default is what 203 of 233 deployed v1 tasks carry).
     // `1.0`: every human-task type's first bundled definition, which is the one
@@ -189,13 +198,13 @@ function hitlInputs(inputs, nodeType, ctx) {
             ...(inputs?.labels !== undefined ? { labels: inputs.labels } : {}),
             recipient,
             ...docvalInputs,
-            ...((isApp || (nodeType === DOC_VALIDATION && doc?.render === 'custom')) && app
+            ...(emitsApp
                 ? {
                     app: {
                         displayName: app.name,
                         name: app.name,
                         key: app.key,
-                        folderPath: app.folderPath,
+                        folderPath: appFolder,
                         ...(app.appSystemName !== undefined ? { appSystemName: app.appSystemName } : {}),
                         // What types the task's arguments (see action-schema.ts): lowered
                         // from the action schema, or the decompiled node's own, verbatim.
@@ -230,6 +239,34 @@ function hitlInputs(inputs, nodeType, ctx) {
         },
     };
 }
+/**
+ * The canvas's legacy placeholder folder for an app inline to the solution. The
+ * platform's own app picker clears it to `''` (flow-v1 `HITLAppPicker.tsx`
+ * `INLINE_APP_FOLDER_TOKEN`, #4076): an inline app has no deploy-time
+ * overwrite, so the token would reach the engine literally and be refused
+ * (170000). Read back as `location: 'in-solution'`, never emitted.
+ */
+const INLINE_APP_FOLDER_TOKEN = 'solution_folder';
+/**
+ * The `app` binding pair for one Action App, through the shared
+ * {@link processResourceBindings}: one pair per app, keyed the way flow-v1's app
+ * picker creates them — by the app's `key` once it has a folder, by its `name`
+ * while it has none (an in-solution app) (`hitl-serialization.ts`,
+ * `HITLAppPicker.tsx`, flow-v1 #3910). The serializer resolves the task's
+ * `<bindings.name>` / `<bindings.folderPath>` context against them; without a
+ * row the placeholder text reaches the engine, and packaging leaves the app out
+ * of `bindings_v2.json`. Serializers before #3910 (flow-converter 0.69) key the
+ * app by name only and fall back to the FIRST row named `name`/`folderPath` of
+ * any resource.
+ */
+function appResourceBindings(spec, existing) {
+    return processResourceBindings({
+        name: spec.name,
+        folderPath: spec.folderPath,
+        resource: 'app',
+        resourceKey: spec.folderPath ? spec.key : spec.name,
+    }, existing).entries;
+}
 /**
  * One `appInputBindings` value: the expression sent to a deployed app's input.
  *
@@ -416,7 +453,10 @@ function liftHitl(node, typeName, ctx) {
         // `displayName` is serialize's echo of `name`; only `name` is authored.
         name: String(app.name ?? ''),
         key: String(app.key ?? ''),
-        ...(typeof app.folderPath === 'string' && app.folderPath !== '' ? { folderPath: app.folderPath } : {}),
+        // No folder (or the canvas's legacy inline placeholder) is how the platform
+        // writes an app inline to the solution.
+        ...(typeof app.folderPath === 'string' && app.folderPath !== '' && app.folderPath !== INLINE_APP_FOLDER_TOKEN
+            ? { folderPath: app.folderPath } : { location: 'in-solution' }),
         ...(app.appSystemName === null ? { appSystemName: null }
             : typeof app.appSystemName === 'string' ? { appSystemName: app.appSystemName } : {}),
         ...(appInputs !== undefined ? { inputs: appInputs } : {}),
@@ -517,6 +557,7 @@ function printHitl({ inputs }, ctx) {
     const app = h.app === undefined ? undefined : obj([
         ['name', ctx.string(h.app.name)],
         ['key', ctx.string(h.app.key)],
+        ['location', h.app.location !== undefined ? ctx.string(h.app.location) : undefined],
         ['folderPath', h.app.folderPath !== undefined ? ctx.string(h.app.folderPath) : undefined],
         ['appSystemName', h.app.appSystemName === null ? 'null'
                 : h.app.appSystemName !== undefined ? ctx.string(h.app.appSystemName) : undefined],

package/dist/nodes/hitl/flow/spec.d.ts

@@ -6,7 +6,7 @@
  * `core/actions.ts`: an agent's quick-form escalation shares them.
  */
 import type { Expr } from '../../../core/expr.js';
-import type { FormField } from '../../../core/actions.js';
+import type { FormField, ProcessLocation } from '../../../core/actions.js';
 /**
  * Where the task is delivered. The four ids are the platform's own — including
  * the lowercase `'teams'`, which is how every deployed recipient spells
@@ -164,15 +164,44 @@ export type HitlVariant = 'quick-form' | 'action-app' | 'document-validation';
  *   },
  *   outcomes: ['Approve', 'Reject'],
  * })
+ *
+ * // A coded action app in the same solution as the flow:
+ * hitl({
+ *   variant: 'action-app',
+ *   app: { name: 'InvoiceReview', key: '<resource.key>', location: 'in-solution' },
+ *   outcomes: ['Approve', 'Reject'],
+ * })
  * ```
  */
 export interface AppRef {
     /** The app's display title, e.g. `'Expense Review'`. */
     name: string;
-    /** The app's key (a GUID) — how the platform resolves which app this is. */
+    /**
+     * The app's key (a GUID) — how the platform resolves which app this is.
+     *
+     * For an in-solution app it is `resource.key` from
+     * `resources/solution_folder/app/codedAction/<App>.json`.
+     */
     key: string;
-    /** Fully-qualified folder the app is deployed in, e.g. `'Shared'`. */
-    folderPath: string;
+    /**
+     * Where the app lives. `'published'` (the default) is an app deployed to
+     * `folderPath`. `'in-solution'` is a coded action app in the same solution as
+     * the flow: it takes no `folderPath` — it is emitted with the empty folder
+     * and name-keyed bindings the platform's own app picker writes for an app
+     * inline to the solution. Needs a `uip` CLI with flow-converter 0.100.3 or
+     * later (or a process engine with MST-15436); older ones fail at run time
+     * with 170004.
+     *
+     * @enforcedBy HITL_APP_LOCAL_HAS_FOLDER An in-solution app takes no folderPath.
+     */
+    location?: ProcessLocation;
+    /**
+     * Fully-qualified folder the app is deployed in, e.g. `'Shared'`. Required
+     * for a published app; omit it for an in-solution one.
+     *
+     * @enforcedBy HITL_APP_INCOMPLETE A published app needs its folder.
+     */
+    folderPath?: string;
     /**
      * The app's stable system name. `null` until the app's first deployment
      * assigns one, which is why it is optional and why `null` is a legal value

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.66.0",
+  "version": "6.66.2",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -100,5 +100,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "5da76743a22cb278ab85acb47169367acbfe65d0"
+  "gitref": "f698c1379d7c348671e6bf0df5b211be77e8f1c6"
 }