@uipath/maestro-builder-sdk 6.46.0 → 6.46.2

package/dist/case/case-expr-check.js

@@ -39,9 +39,18 @@ export function checkCaseExpressions(built) {
     // task output is not flagged as an undeclared reference.
     for (const stage of built.stages)
         for (const lane of stage.lanes)
-            for (const task of lane)
+            for (const task of lane) {
                 for (const o of task.outputs ?? [])
                     roots.add(o.var);
+                // A human task's form outputs declare one too: the field's `value` is the
+                // variable the assignee's answer lands in (`.action({ outputs: [{ name:
+                // 'Action', value: 'decision' }] })` → `vars.decision`). The serializer
+                // registers exactly that companion (`emitActionField`), so a gate on it
+                // is a declared read, not a typo.
+                for (const f of task.action?.outputs ?? [])
+                    if (f.value)
+                        roots.add(f.value);
+            }
     // Event-trigger payload extractions declare readable case variables too.
     for (const t of built.triggers)
         for (const o of t.eventOutputs ?? [])

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

@@ -432,7 +432,13 @@ export interface TaskRef {
  * Options for {@link TaskBuilder.businessRule}.
  */
 export interface BusinessRuleOptions {
-    /** The Orchestrator folder the rule is deployed in, e.g. `Shared`. */
+    /**
+     * The Orchestrator folder the rule is deployed in, e.g. `Shared`. For a rule
+     * built in the same solution as the case, pass `'solution_folder'` (the folder
+     * `registry search --local` reports): the binding is keyed
+     * `solution_folder.<name>` and its folderPath is left empty, so the case runs
+     * the rule from its own deployed folder.
+     */
     folder: string;
     /**
      * The rule's whole result schema, as `uip maestro case tasks describe --type

package/dist/case/compile-cli.d.ts

@@ -1,3 +1,13 @@
 #!/usr/bin/env node
 import { type CliExitCode } from '../cli-run.js';
 export declare function run(argv: string[]): Promise<CliExitCode>;
+/**
+ * Write the entry point's id onto its trigger, as `data.inputs.entryPointId`.
+ *
+ * The Case Designer pairs a trigger with its entry point through this field.
+ * A trigger without it gets a fresh GUID on the first open, and the entry
+ * point's `uniqueId` is rewritten to match, so the entry point changes identity
+ * (MST-16422; `validate --strict` warns STRICT_TRIGGER_ENTRY_POINT_ID). The
+ * Designer writes it last among the inputs, so it is appended.
+ */
+export declare function stampEntryPointId(trigger: any, uniqueId: string): void;

package/dist/case/compile-cli.js

@@ -28,6 +28,7 @@ import { defaultBindingsFile } from '../workdir.js';
 import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
 import { CASE_FORMAT_PROFILE } from './format-profile.js';
+import { isInSolutionKey, SOLUTION_FOLDER } from './resource-identity.js';
 import { sha256Uuid } from '../core/stable-id.js';
 import { isRecord } from '../core/node-envelope.js';
 export async function run(argv) {
@@ -81,9 +82,11 @@ export async function run(argv) {
         reportDiagnostics([...diags, thrownDiagnostic(error)]);
         throw error;
     }
+    // Entry points first: each trigger carries its entry point's `uniqueId` as
+    // `data.inputs.entryPointId`, so the plan is written after the ids are known.
+    const triggers = syncEntryPoints(caseplan, out);
     writeJsonFile(out, caseplan);
     const stages = caseplan.nodes.filter((n) => String(n.type).endsWith('Stage')).length;
-    const triggers = syncEntryPoints(caseplan, out);
     const epNote = triggers >= 0 ? `, synced entry-points.json (${triggers} trigger(s))` : '';
     const resources = syncBindingsV2(caseplan, out);
     const bindingsNote = resources >= 0 ? `, synced bindings_v2.json (${resources} resource(s))` : '';
@@ -229,6 +232,25 @@ function describedCaseFileName(dir) {
 function packagedCaseFileName(dir, outPath) {
     return shippedCasePlanName(dir) ?? basename(outPath);
 }
+/**
+ * Write the entry point's id onto its trigger, as `data.inputs.entryPointId`.
+ *
+ * The Case Designer pairs a trigger with its entry point through this field.
+ * A trigger without it gets a fresh GUID on the first open, and the entry
+ * point's `uniqueId` is rewritten to match, so the entry point changes identity
+ * (MST-16422; `validate --strict` warns STRICT_TRIGGER_ENTRY_POINT_ID). The
+ * Designer writes it last among the inputs, so it is appended.
+ */
+export function stampEntryPointId(trigger, uniqueId) {
+    if (typeof uniqueId !== 'string' || !uniqueId)
+        return;
+    trigger.data ??= {};
+    const inputs = trigger.data.inputs;
+    if (inputs !== undefined && (typeof inputs !== 'object' || inputs === null || Array.isArray(inputs)))
+        return;
+    const { entryPointId: _old, ...rest } = (inputs ?? {});
+    trigger.data.inputs = { ...rest, entryPointId: uniqueId };
+}
 /**
  * Keep the sibling `entry-points.json` in step with the caseplan's trigger nodes:
  * the runtime discovers triggers there, so a trigger node with no matching
@@ -251,9 +273,11 @@ function syncEntryPoints(caseplan, outPath) {
         // Project the case's In/Out args into this trigger's input/output schemas
         // (In-args scoped to this trigger by elementId; Out-args to every entry).
         const { input, output } = entryPointIO(caseplan.variables, n.id);
+        const uniqueId = prev?.uniqueId ?? sha256Uuid(`entrypoint:${n.id}`);
+        stampEntryPointId(n, uniqueId);
         return {
             filePath: `/content/${base}.bpmn#${n.id}`,
-            uniqueId: prev?.uniqueId ?? sha256Uuid(`entrypoint:${n.id}`),
+            uniqueId,
             type: 'CaseManagement',
             input,
             output,
@@ -297,8 +321,14 @@ function syncBindingsV2(caseplan, outPath) {
             grouped.set(groupKey, group);
         }
         const property = stringValue(binding.propertyAttribute) ?? stringValue(binding.name);
+        // An in-solution resource binds an empty folderPath in the caseplan, while
+        // the sidecar names its folder by the sentinel the key carries — the split
+        // `uip maestro case bindings sync` writes (resource-identity.ts).
+        const defaultValue = property === 'folderPath' && isInSolutionKey(key)
+            ? SOLUTION_FOLDER
+            : binding.default ?? key;
         if (property)
-            group.value[property] = { defaultValue: binding.default ?? key };
+            group.value[property] = { defaultValue };
         const subType = stringValue(binding.resourceSubType);
         if (subType)
             group.subType = subType;

package/dist/case/decompile.js

@@ -4,6 +4,7 @@ import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { preserveSchemaVersion } from '../schema-version.js';
 import { ownEntry } from '../core/own-entry.js';
 import { isUnrestorableSlotId } from './preserve.js';
+import { isInSolutionKey, SOLUTION_FOLDER } from './resource-identity.js';
 const TASK_KIND_METHOD = {
     process: 'process',
     agent: 'agent',
@@ -133,6 +134,10 @@ function encodedSubscriptionConfig(context, owner) {
         throw new Error(`${owner} has malformed subscription metadata configuration JSON.`);
     }
 }
+/** A plain object with no keys — the Designer's spelling of an empty subscription body. */
+function isEmptyObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).length === 0;
+}
 function subscriptionWhere(bag, owner) {
     const inputs = bag.inputs;
     if (!Array.isArray(inputs) || inputs.length !== 1)
@@ -142,6 +147,11 @@ function subscriptionWhere(bag, owner) {
         throw new Error(`${owner} has an unsupported subscription input.`);
     if (row.value === '' && row.body === undefined)
         return undefined;
+    // The Case Designer saves a subscription with no parameters (an HTTP webhook,
+    // say) as `body: {}` with no `value`. That is the same "no where" the SDK
+    // writes as `value: ''`, not an unsupported body.
+    if (isEmptyObject(row.body) && (row.value === undefined || row.value === ''))
+        return undefined;
     const queryParams = row.body?.queryParams;
     if (!queryParams || typeof queryParams !== 'object' || Array.isArray(queryParams))
         throw new Error(`${owner} has an unsupported subscription body.`);
@@ -340,6 +350,21 @@ function bindingDefault(value, refs) {
     const id = value.slice('=bindings.'.length);
     return refs.bindingById.get(id)?.default ?? value;
 }
+/**
+ * The folder a resource task's `folderPath` reference names, as the author
+ * writes it. An in-solution resource binds an empty folderPath under a
+ * `solution_folder.<name>` key; the builder spells that folder `solution_folder`
+ * (resource-identity.ts), so lift the sentinel back rather than the empty
+ * default, which would recompile to the key `.<name>`.
+ */
+function bindingFolder(value, refs) {
+    if (typeof value === 'string' && value.startsWith('=bindings.')) {
+        const row = refs.bindingById.get(value.slice('=bindings.'.length));
+        if (typeof row?.resourceKey === 'string' && isInSolutionKey(row.resourceKey))
+            return SOLUTION_FOLDER;
+    }
+    return bindingDefault(value, refs);
+}
 function selectNextStageByExit(plan, refs) {
     const raw = plan.metadata?.waitForHumanSelectNextStageDFConnector;
     if (raw === undefined)
@@ -505,10 +530,17 @@ function externalCall(task, refs, library) {
         throw new Error(`${owner} has unsupported serviceType "${String(data.serviceType ?? '')}".`);
     if (!Array.isArray(data.context))
         throw new Error(`${owner} requires a resolved context array.`);
+    // A trailing `activityConfigurationVersion: v2` row only picks the Designer
+    // panel; compile writes it back from the plan's `intsvcActivityConfig` flag.
+    const rows = data.context;
+    const last = rows[rows.length - 1];
+    const configRows = last?.name === 'activityConfigurationVersion' && last.value === 'v2' && last.type === 'string'
+        ? rows.slice(0, -1)
+        : rows;
     const expectedContext = ['activity', 'connectorKey', 'connection', 'folderKey', 'method', 'path'];
-    if (data.context.map((row) => row.name).join('\0') !== expectedContext.join('\0'))
-        throw new Error(`${owner} context must contain exactly ${expectedContext.join(', ')} in canonical order.`);
-    const context = contextMap(data);
+    if (configRows.map((row) => row.name).join('\0') !== expectedContext.join('\0'))
+        throw new Error(`${owner} context must contain exactly ${expectedContext.join(', ')} in canonical order, optionally followed by activityConfigurationVersion v2.`);
+    const context = contextMap({ context: configRows });
     const stringValue = (name) => {
         const row = context.get(name);
         if (row?.type !== 'string' || typeof row.value !== 'string' || !row.value)
@@ -643,7 +675,7 @@ function businessRuleCall(task, refs) {
     const data = task.data ?? {};
     const owner = `business-rule task "${task.displayName ?? task.id ?? '?'}"`;
     const name = bindingDefault(data.name, refs);
-    const folderPath = bindingDefault(data.folderPath, refs);
+    const folderPath = bindingFolder(data.folderPath, refs);
     if (typeof name !== 'string' || !name || typeof folderPath !== 'string')
         throw new Error(`${owner} must name its rule and folder (data.name / data.folderPath).`);
     const outputRow = (Array.isArray(data.outputs) ? data.outputs : [])

package/dist/case/resource-identity.d.ts

@@ -0,0 +1,36 @@
+/**
+ * How a Case resource task names the resource it runs: the `resourceKey` its
+ * root binding pair shares, and the `folderPath` default the runtime reads.
+ *
+ * For a resource deployed to a tenant folder the two agree:
+ *
+ *   folder 'Shared/Finance', name 'CreditRisk'
+ *     -> resourceKey 'Shared/Finance.CreditRisk', folderPath 'Shared/Finance'
+ *
+ * For a sibling built inside the same solution they do not. Its folder is the
+ * `solution_folder` sentinel (what `uip maestro case registry search --local`
+ * and `resources/solution_folder/...` report), and the platform splits it:
+ *
+ *   folder 'solution_folder', name 'CreditRisk'
+ *     -> resourceKey 'solution_folder.CreditRisk', folderPath ''
+ *
+ * The key keeps the sentinel because deploy and `resources refresh` match the
+ * resource by it. The `folderPath` default is empty because the running case
+ * starts the sibling in its own deployed folder; a literal `solution_folder`
+ * there passes `validate` and fails the task at runtime with "Folder does not
+ * exist". The CLI encodes the same split: `case-bindings-service.ts` writes the
+ * sentinel into `bindings_v2.json` for a `solution_folder.` key, and
+ * `case-validate-service.ts` exempts that prefix from its key/folder agreement
+ * check.
+ */
+export declare const SOLUTION_FOLDER = "solution_folder";
+export interface ResourceIdentity {
+    /** The `resourceKey` both rows of the name/folderPath binding pair carry. */
+    resourceKey: string;
+    /** The `default` of the `folderPath` binding row. */
+    folderPath: string;
+}
+/** The binding identity of resource `name` authored in `folder`. */
+export declare function resourceIdentity(name: string, folder: string): ResourceIdentity;
+/** True for the key of a resource built inside the same solution. */
+export declare function isInSolutionKey(resourceKey: string): boolean;

package/dist/case/resource-identity.js

@@ -0,0 +1,37 @@
+/**
+ * How a Case resource task names the resource it runs: the `resourceKey` its
+ * root binding pair shares, and the `folderPath` default the runtime reads.
+ *
+ * For a resource deployed to a tenant folder the two agree:
+ *
+ *   folder 'Shared/Finance', name 'CreditRisk'
+ *     -> resourceKey 'Shared/Finance.CreditRisk', folderPath 'Shared/Finance'
+ *
+ * For a sibling built inside the same solution they do not. Its folder is the
+ * `solution_folder` sentinel (what `uip maestro case registry search --local`
+ * and `resources/solution_folder/...` report), and the platform splits it:
+ *
+ *   folder 'solution_folder', name 'CreditRisk'
+ *     -> resourceKey 'solution_folder.CreditRisk', folderPath ''
+ *
+ * The key keeps the sentinel because deploy and `resources refresh` match the
+ * resource by it. The `folderPath` default is empty because the running case
+ * starts the sibling in its own deployed folder; a literal `solution_folder`
+ * there passes `validate` and fails the task at runtime with "Folder does not
+ * exist". The CLI encodes the same split: `case-bindings-service.ts` writes the
+ * sentinel into `bindings_v2.json` for a `solution_folder.` key, and
+ * `case-validate-service.ts` exempts that prefix from its key/folder agreement
+ * check.
+ */
+export const SOLUTION_FOLDER = 'solution_folder';
+const SOLUTION_FOLDER_KEY_PREFIX = `${SOLUTION_FOLDER}.`;
+/** The binding identity of resource `name` authored in `folder`. */
+export function resourceIdentity(name, folder) {
+    if (folder === SOLUTION_FOLDER)
+        return { resourceKey: `${SOLUTION_FOLDER_KEY_PREFIX}${name}`, folderPath: '' };
+    return { resourceKey: `${folder}.${name}`, folderPath: folder };
+}
+/** True for the key of a resource built inside the same solution. */
+export function isInSolutionKey(resourceKey) {
+    return resourceKey.startsWith(SOLUTION_FOLDER_KEY_PREFIX);
+}

package/dist/case/serialize.js

@@ -18,6 +18,7 @@ import { resolveEventWhere } from '../core/lookups.js';
 import { resolveCaseSubscription } from './subscription.js';
 import { externalDescriptorRefusal } from './external.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
+import { resourceIdentity } from './resource-identity.js';
 import { resolveSchemaVersion } from '../schema-version.js';
 import { caseJsonPreservation, caseJsonPreservationErrors, } from './preserve.js';
 import { readEventFilter, eventFilterProblem, eventFilterTreeLeaf } from '../core/event-filters.js';
@@ -248,7 +249,49 @@ export function serialize(built, opts = {}) {
             }
             : {}),
     };
-    return applyAuthorLayout(applyPreservation(result, caseJsonPreservation(built)), built.layout);
+    return stampConnectorConfigVersion(applyAuthorLayout(applyPreservation(result, caseJsonPreservation(built)), built.layout));
+}
+/** The task types whose `data.context[]` carries an Integration Service activity configuration. */
+const CONNECTOR_CONFIG_TASK_TYPES = new Set([
+    'execute-connector-activity',
+    'wait-for-connector',
+    'external-agent',
+    'external-workflow',
+]);
+const V2_CONFIG_ROW = { name: 'activityConfigurationVersion', value: 'v2', type: 'string' };
+/**
+ * Flagged-V2 plans: mark each connector task's and event trigger's context
+ * `activityConfigurationVersion: v2`, as the Designer and CLI do. Runs
+ * post-preservation because the flag is preserved metadata.
+ *
+ * Only a context bound to a connection is marked. A placeholder bag
+ * (`connectorKey` + `operation`, or a trigger's lone `objectName`) has no
+ * configuration panel to pick. A context that already carries the row keeps it.
+ */
+function stampConnectorConfigVersion(result) {
+    const metadata = result.metadata;
+    if (metadata?.intsvcActivityConfig !== 'v2')
+        return result;
+    const stamp = (context) => {
+        if (!Array.isArray(context))
+            return;
+        if (!context.some((row) => row?.name === 'connection'))
+            return;
+        if (context.some((row) => row?.name === V2_CONFIG_ROW.name))
+            return;
+        context.push({ ...V2_CONFIG_ROW });
+    };
+    for (const node of result.nodes ?? []) {
+        if (node?.type === 'case-management:Trigger' || node?.type === 'uipath.case.trigger')
+            stamp(node.data?.[CASE_FORMAT_PROFILE.triggerBagField]?.context);
+        for (const lane of node?.data?.tasks ?? []) {
+            for (const task of Array.isArray(lane) ? lane : []) {
+                if (CONNECTOR_CONFIG_TASK_TYPES.has(task?.type))
+                    stamp(task.data?.context);
+            }
+        }
+    }
+    return result;
 }
 const CASE_NODE_LAYOUT_FIELDS = ['position', 'style', 'measured', 'width', 'height', 'zIndex'];
 /**
@@ -1142,7 +1185,8 @@ function businessRuleBinding(resolver, ids, resourceKey, propertyAttribute, valu
  *
  * - `name` / `folderPath` are `=bindings.<id>` references to a `BusinessRule`
  *   binding pair keyed `<folder>.<name>` (the runtime resolves the rule through
- *   them; `validate --strict` refuses literals);
+ *   them; `validate --strict` refuses literals). An in-solution rule is keyed
+ *   `solution_folder.<name>` with an empty folderPath default;
  * - `version: 'v3'`;
  * - `outputs` always starts with `output` (`source: '=result'`, the whole
  *   decision-keyed result) and `Error` (`source: '=Error'`), followed by the
@@ -1151,9 +1195,11 @@ function businessRuleBinding(resolver, ids, resourceKey, propertyAttribute, valu
  */
 function businessRuleTaskData(task, resolver, elementId, ids) {
     const ref = task.ref;
-    const resourceKey = `${ref.folderPath}.${ref.name}`;
+    // An in-solution rule (`folder: 'solution_folder'`) keeps the sentinel in its
+    // key and binds an empty folderPath — see resource-identity.ts.
+    const { resourceKey, folderPath } = resourceIdentity(ref.name, ref.folderPath);
     const nameId = businessRuleBinding(resolver, ids, resourceKey, 'name', ref.name);
-    const folderId = businessRuleBinding(resolver, ids, resourceKey, 'folderPath', ref.folderPath);
+    const folderId = businessRuleBinding(resolver, ids, resourceKey, 'folderPath', folderPath);
     const ownRow = (name, source, seed, extra = {}) => {
         const slot = ids.make('v', 8, `${elementId}:${seed}`);
         return { name, type: 'jsonSchema', id: slot, var: slot, value: slot, source, target: `=${slot}`, elementId, ...extra };

package/package.json

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