@uipath/maestro-builder-sdk 6.46.1 → 6.46.3

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
@@ -759,7 +765,7 @@ declare class TaskBuilder {
      * Reference a published Maestro process.
      *
      * @param name - The published process's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     process(name: string, opts?: {
@@ -782,7 +788,7 @@ declare class TaskBuilder {
      * Reference a published agent.
      *
      * @param name - The published agent's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     agent(name: string, opts?: {
@@ -792,7 +798,7 @@ declare class TaskBuilder {
      * Reference a published RPA process.
      *
      * @param name - The published RPA process's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     rpa(name: string, opts?: {
@@ -802,7 +808,7 @@ declare class TaskBuilder {
      * Reference a published API workflow.
      *
      * @param name - The published API workflow's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     apiWorkflow(name: string, opts?: {
@@ -814,7 +820,7 @@ declare class TaskBuilder {
      * io-binding as reference-mode tasks.
      *
      * @param name - The published child case's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     caseManagement(name: string, opts?: {
@@ -824,7 +830,7 @@ declare class TaskBuilder {
      * Reference a published Maestro Flow.
      *
      * @param name - The published Flow's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     flowProcess(name: string, opts?: {

package/dist/case/case-sdk.js

@@ -190,7 +190,7 @@ class TaskBuilder {
      * Reference a published Maestro process.
      *
      * @param name - The published process's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     process(name, opts) {
@@ -216,7 +216,7 @@ class TaskBuilder {
      * Reference a published agent.
      *
      * @param name - The published agent's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     agent(name, opts) {
@@ -226,7 +226,7 @@ class TaskBuilder {
      * Reference a published RPA process.
      *
      * @param name - The published RPA process's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     rpa(name, opts) {
@@ -236,7 +236,7 @@ class TaskBuilder {
      * Reference a published API workflow.
      *
      * @param name - The published API workflow's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     apiWorkflow(name, opts) {
@@ -248,7 +248,7 @@ class TaskBuilder {
      * io-binding as reference-mode tasks.
      *
      * @param name - The published child case's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     caseManagement(name, opts) {
@@ -258,7 +258,7 @@ class TaskBuilder {
      * Reference a published Maestro Flow.
      *
      * @param name - The published Flow's name.
-     * @param opts - `folder` — the Orchestrator folder it lives in.
+     * @param opts - `folder` — the Orchestrator folder it lives in, or `'solution_folder'` (the default when omitted) for one built in this solution. Compile binds the task through a name/folderPath pair of root bindings keyed `<folder>.<name>`.
      * @returns This builder, so calls chain.
      */
     flowProcess(name, opts) {

package/dist/case/check.js

@@ -483,6 +483,17 @@ function checkStage(stage, diags, refStage, refPlacement) {
                 message: `Task "${t.name}" binding "${'var' in invalidBinding ? invalidBinding.var : invalidBinding.name}" has unsupported type ${JSON.stringify(invalidBinding.type)}. Use a type name such as "string" or "jsonSchema"; jsonSchema(...) is only for declaring a structured case variable.`,
                 where: t.name,
             });
+        // The builder binds a resource task itself: it mints the name/folderPath
+        // binding pair from the literal name and folder. A `=bindings.<id>` string
+        // passed as either becomes part of the binding key, which then names no
+        // resource (`=bindings.f.=bindings.n`) and dangles at deploy.
+        if (t.ref && [t.ref.name, t.ref.folderPath].some((v) => v.trim().startsWith('=bindings.')))
+            diags.push({
+                level: 'error',
+                code: 'RESOURCE_REF_IS_BINDING',
+                message: `Task "${t.name}" passes a "=bindings.<id>" reference as its resource name or folder. Pass the resource's own name and its folder, e.g. .agent('Contract Analysis', { folder: 'Shared/Legal' }); compile writes the name/folderPath binding pair keyed '<folder>.<name>' and points the task at it.`,
+                where: t.name,
+            });
         if (t.kind === 'business-rule') {
             if (!t.ref || !t.ref.name.trim() || !t.ref.folderPath.trim())
                 diags.push({

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,
@@ -268,7 +292,8 @@ function syncEntryPoints(caseplan, outPath) {
  * artifact. `resources refresh` reads bindings_v2.json, not caseplan.json, and
  * succeeds with zero warnings when the sidecar is stale or empty.
  *
- * Non-connector resources come from root binding pairs and referenced tasks.
+ * Non-connector resources come from the root binding rows only, as in
+ * `uip maestro case bindings sync`.
  * A connector's connection and folder relationship comes from the context[]
  * that references both binding ids.
  * No-op when compiling outside a scaffolded project.
@@ -284,59 +309,29 @@ function syncBindingsV2(caseplan, outPath) {
         .filter((binding) => typeof binding.id === 'string')
         .map((binding) => [binding.id, binding]));
     const resources = [];
-    const grouped = new Map();
+    // One entry per (resource, resourceKey) group of root binding rows, in the
+    // shape `uip maestro case bindings sync` derives (`deriveCaseBindingsV2` in
+    // cli case-bindings-service.ts). `validate --strict` compares the two
+    // entry by entry as serialized JSON, so field order matters as well as
+    // field values.
+    const groups = new Map();
     for (const binding of bindings) {
         const resource = stringValue(binding.resource);
         const key = stringValue(binding.resourceKey);
-        if (!resource || !key || resource.toLowerCase() === 'connection')
+        if (!resource || !key || typeof binding.propertyAttribute !== 'string')
+            continue;
+        if (resource.toLowerCase() === 'connection')
             continue;
         const groupKey = `${resource}\0${key}`;
-        let group = grouped.get(groupKey);
-        if (!group) {
-            group = { resource, key, value: {} };
-            grouped.set(groupKey, group);
-        }
-        const property = stringValue(binding.propertyAttribute) ?? stringValue(binding.name);
-        if (property)
-            group.value[property] = { defaultValue: binding.default ?? key };
-        const subType = stringValue(binding.resourceSubType);
-        if (subType)
-            group.subType = subType;
+        const group = groups.get(groupKey);
+        if (group)
+            group.push(binding);
+        else
+            groups.set(groupKey, [binding]);
     }
-    const referenceTaskSubTypes = new Map([
-        ['process', 'ProcessOrchestration'],
-        ['agent', 'Agent'],
-        ['rpa', undefined],
-        ['api-workflow', 'Api'],
-        ['case-management', 'CaseManagement'],
-        ['flow-process', 'ProcessOrchestration'],
-    ]);
     const seenConnections = new Set();
     const connectionResources = [];
     visitRecords(caseplan, (record) => {
-        const type = stringValue(record.type);
-        const data = isRecord(record.data) ? record.data : undefined;
-        if (type && data && referenceTaskSubTypes.has(type)) {
-            const name = referencedBindingValue(data.name, byId);
-            const folderPath = referencedBindingValue(data.folderPath, byId);
-            if (name && folderPath) {
-                const key = referencedBindingResourceKey(data.name, byId)
-                    ?? referencedBindingResourceKey(data.folderPath, byId)
-                    ?? `${folderPath}.${name}`;
-                const groupKey = `process\0${key}`;
-                if (!grouped.has(groupKey)) {
-                    grouped.set(groupKey, {
-                        resource: 'process',
-                        key,
-                        value: {
-                            name: { defaultValue: name },
-                            folderPath: { defaultValue: folderPath },
-                        },
-                        subType: referenceTaskSubTypes.get(type),
-                    });
-                }
-            }
-        }
         if (!Array.isArray(record.context))
             return;
         const context = new Map(record.context
@@ -359,23 +354,126 @@ function syncBindingsV2(caseplan, outPath) {
             metadata: { connector },
         });
     });
-    for (const group of grouped.values()) {
-        resources.push({
-            resource: group.resource,
-            key: group.key,
-            value: group.value,
-            // A BusinessRule entry carries the bindings version deploy needs to
-            // override its folder — the metadata `uip maestro case bindings sync`
-            // writes for it (no subType).
-            metadata: group.subType
-                ? { subType: group.subType }
-                : group.resource === 'BusinessRule' ? { BindingsVersion: '2.2' } : {},
-        });
-    }
+    const labels = bindingLabels(caseplan.nodes);
+    for (const group of groups.values())
+        resources.push(sidecarResourceEntry(group, labels));
     resources.push(...connectionResources);
     writeJsonFile(sidecarPath, { version: '2.0', resources });
     return resources.length;
 }
+/**
+ * The Case Designer's label for each value slot of an app or process entry.
+ * These resources get the Designer shape (cli#5003, MST-16424): an `id`, each
+ * slot flagged and labelled, and the `BindingsVersion` / `SolutionsSupport`
+ * metadata without which deploy cannot override the entry.
+ */
+const DESIGNER_SLOT_NAMES = new Map([
+    ['app', { name: 'App name', folderPath: 'Folder path', solutionsSupport: true }],
+    ['process', { name: 'Process name', folderPath: 'Folder path', solutionsSupport: true }],
+    ['ixpDeployment', { name: 'name', folderPath: 'Folder path', solutionsSupport: false }],
+]);
+/** The bindings version deploy needs to override an entry. */
+const RESOURCE_BINDINGS_VERSION = '2.2';
+/**
+ * One sidecar entry for a group of root binding rows that share a resource and
+ * a resource key. The subtype comes from the rows only: a Flow's rows carry
+ * none, so its entry has none either, as the Designer saves it.
+ *
+ * `metadata.ActivityName` labels a Designer-shaped entry with the first task
+ * that references one of its rows ({@link bindingLabels}).
+ */
+function sidecarResourceEntry(group, labels) {
+    const resource = group[0].resource;
+    const key = group[0].resourceKey;
+    const attributeDefault = (attribute) => {
+        const found = group.find((binding) => binding.propertyAttribute === attribute)?.default;
+        return typeof found === 'string' ? found : undefined;
+    };
+    // An in-solution resource binds an empty folderPath in the caseplan, while
+    // the sidecar names its folder by the sentinel the key carries.
+    const folderPath = isInSolutionKey(key) ? SOLUTION_FOLDER : attributeDefault('folderPath');
+    const name = attributeDefault('name');
+    const subType = group.map((binding) => binding.resourceSubType).find((found) => found !== undefined);
+    const designer = DESIGNER_SLOT_NAMES.get(resource);
+    if (designer) {
+        const value = {};
+        if (folderPath !== undefined) {
+            value.folderPath = { defaultValue: folderPath, isExpression: false, displayName: designer.folderPath };
+        }
+        if (name !== undefined) {
+            value.name = { defaultValue: name, isExpression: false, displayName: designer.name };
+        }
+        const activityName = group
+            .map((binding) => (typeof binding.id === 'string' ? labels.get(binding.id) : undefined))
+            .find((found) => found !== undefined);
+        return {
+            resource,
+            key,
+            id: `${resource}${key}`,
+            value,
+            metadata: {
+                ...(activityName !== undefined && { ActivityName: activityName }),
+                BindingsVersion: RESOURCE_BINDINGS_VERSION,
+                DisplayLabel: 'name',
+                ...(designer.solutionsSupport && { SolutionsSupport: 'true' }),
+                ...(subType !== undefined && { subType }),
+            },
+        };
+    }
+    const value = {};
+    if (name !== undefined)
+        value.name = { defaultValue: name };
+    if (folderPath !== undefined)
+        value.folderPath = { defaultValue: folderPath };
+    // A solution-resource picker (such as a Data Fabric entity) carries its folder key as a slot of its own.
+    const folderKey = attributeDefault('folderKey');
+    if (folderKey !== undefined)
+        value.folderKey = { defaultValue: folderKey };
+    return {
+        resource,
+        key,
+        value,
+        metadata: {
+            BindingsVersion: RESOURCE_BINDINGS_VERSION,
+            ...(subType !== undefined && { subType }),
+        },
+    };
+}
+/**
+ * The label of the first object that references each binding id
+ * (`=bindings.<id>`), in document order: the nearest enclosing `displayName`,
+ * `display.label` or `label`. The same walk as the CLI's
+ * `collectBindingLabels`, so both name an entry after the same task.
+ */
+function bindingLabels(nodes) {
+    const found = new Map();
+    const ownLabel = (node) => {
+        const display = isRecord(node.display) ? node.display.label : undefined;
+        return [node.displayName, display, node.label].map(stringValue).find((label) => label !== undefined);
+    };
+    const walk = (node, label) => {
+        if (typeof node === 'string') {
+            if (label !== undefined && node.startsWith('=bindings.')) {
+                const id = node.slice('=bindings.'.length);
+                if (!found.has(id))
+                    found.set(id, label);
+            }
+            return;
+        }
+        if (Array.isArray(node)) {
+            for (const item of node)
+                walk(item, label);
+            return;
+        }
+        if (!isRecord(node))
+            return;
+        const scoped = ownLabel(node) ?? label;
+        for (const value of Object.values(node))
+            walk(value, scoped);
+    };
+    walk(nodes ?? [], undefined);
+    return found;
+}
 function referencedBindingValue(value, bindings) {
     const ref = stringValue(value);
     if (!ref)
@@ -385,12 +483,6 @@ function referencedBindingValue(value, bindings) {
     const binding = bindings.get(ref.slice('=bindings.'.length));
     return binding && (stringValue(binding.default) ?? stringValue(binding.resourceKey));
 }
-function referencedBindingResourceKey(value, bindings) {
-    const ref = stringValue(value);
-    if (!ref?.startsWith('=bindings.'))
-        return undefined;
-    return stringValue(bindings.get(ref.slice('=bindings.'.length))?.resourceKey);
-}
 function visitRecords(value, visit) {
     if (Array.isArray(value)) {
         for (const item of value)

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.`);
@@ -334,11 +344,39 @@ function bindingName(value, refs) {
     const id = value.slice('=bindings.'.length);
     return refs.bindingById.get(id)?.id ?? id;
 }
-function bindingDefault(value, refs) {
+/**
+ * The literal a resource task's `data.name` / `data.folderPath` names: the
+ * value itself, or the `default` of the root binding row a `=bindings.<id>`
+ * reference points at. A reference the plan's root `bindings[]` cannot answer
+ * (no such row, or a row with no `default`) is refused: the plan names no
+ * resource there, and emitting the reference as the name would only fail
+ * again at compile.
+ */
+function bindingDefault(value, refs, owner, field) {
     if (typeof value !== 'string' || !value.startsWith('=bindings.'))
         return value;
     const id = value.slice('=bindings.'.length);
-    return refs.bindingById.get(id)?.default ?? value;
+    const row = refs.bindingById.get(id);
+    if (typeof row?.default !== 'string')
+        throw new Error(`${owner} data.${field} is "${value}", but the plan's root bindings ${row ? `row "${id}" has no default` : `declare no row "${id}"`}, `
+            + `so decompile cannot recover the resource ${field === 'name' ? 'name' : 'folder'}. `
+            + `Give the task a name/folderPath binding pair whose rows carry the resource's name and folder as their defaults (what Studio Web writes), then decompile again.`);
+    return row.default;
+}
+/**
+ * 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, owner) {
+    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, owner, 'folderPath');
 }
 function selectNextStageByExit(plan, refs) {
     const raw = plan.metadata?.waitForHumanSelectNextStageDFConnector;
@@ -505,10 +543,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)
@@ -574,9 +619,12 @@ function emitTaskKind(task, refs, library) {
                 throw new Error(`unresolved ${kind} task "${task.displayName ?? task.id ?? '?'}" cannot carry input or output bindings.`);
             return `.unresolved(${tsLiteral(kind)})`;
         }
-        const name = bindingDefault(data.name, refs);
-        const folderPath = bindingDefault(data.folderPath, refs);
-        const folder = folderPath ? `, ${opts([['folder', tsLiteral(folderPath)]])}` : '';
+        const owner = `${kind} task "${task.displayName ?? task.id ?? '?'}"`;
+        const name = bindingDefault(data.name, refs, owner, 'name');
+        const folderPath = bindingFolder(data.folderPath, refs, owner);
+        // No folder already means the case's own solution folder
+        // (resource-identity.ts), so an in-solution resource decompiles to none.
+        const folder = folderPath && folderPath !== SOLUTION_FOLDER ? `, ${opts([['folder', tsLiteral(folderPath)]])}` : '';
         return `.${method}(${tsLiteral(name ?? '')}${folder})`;
     }
     if (isAuthorableBusinessRule(task))
@@ -642,8 +690,8 @@ function isBusinessRuleOwnOutput(row) {
 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 name = bindingDefault(data.name, refs, owner, 'name');
+    const folderPath = bindingFolder(data.folderPath, refs, owner);
     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,44 @@
+/**
+ * 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`. No folder
+ * means the case's own solution folder, the same as `solution_folder`:
+ *
+ *   .process('notify') -> resourceKey 'solution_folder.notify', folderPath ''
+ *
+ * (A literal `.notify` key would name no folder, and deploy and `resources
+ * refresh` could not match it.)
+ */
+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,45 @@
+/**
+ * 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`. No folder
+ * means the case's own solution folder, the same as `solution_folder`:
+ *
+ *   .process('notify') -> resourceKey 'solution_folder.notify', folderPath ''
+ *
+ * (A literal `.notify` key would name no folder, and deploy and `resources
+ * refresh` could not match it.)
+ */
+export function resourceIdentity(name, folder) {
+    if (folder === SOLUTION_FOLDER || !folder.trim())
+        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);
+}