@uipath/maestro-builder-sdk 6.46.2 → 6.46.4

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

@@ -491,6 +491,16 @@ export interface ActionField {
         label: string;
     }>;
 }
+/** The Action App an action task opens. */
+export interface ActionAppRef {
+    /** The app's deployment title, e.g. `SimpleApprovalApp`. */
+    name: string;
+    /**
+     * The app's deployment folder, e.g. `Shared/Approvals`, or `'solution_folder'`
+     * for an app built in this solution.
+     */
+    folder: string;
+}
 export interface ActionSpecData {
     title?: string;
     priority?: 'Low' | 'Medium' | 'High' | 'Critical';
@@ -500,7 +510,11 @@ export interface ActionSpecData {
     };
     /** Action Center labels (persisted as a single `data.labels` string). */
     labels?: string;
-    /** The Action Center action-app / catalog this task instantiates. */
+    /**
+     * An Action Center task catalog, resolved by name in the app's deployment
+     * folder. Not the app: a catalog only groups tasks. Omit it unless the catalog
+     * is known to exist there.
+     */
     actionCatalogName?: string;
     /** Read-only context fields the assignee sees (`data.inputs[]`). */
     inputs?: ActionField[];
@@ -544,6 +558,7 @@ export interface BuiltTask {
     /** Task key + display name (also the handle used by `selected-tasks-completed`). */
     name: string;
     kind: TaskKind;
+    /** The published resource the task binds: a reference task's process, agent, … or an action task's Action App. */
     ref?: TaskRef;
     /** business-rule task: the rule's decision-keyed result schema, when known. */
     businessRule?: BusinessRuleSpecData;
@@ -765,7 +780,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?: {
@@ -788,7 +803,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?: {
@@ -798,7 +813,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?: {
@@ -808,7 +823,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?: {
@@ -820,7 +835,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?: {
@@ -830,7 +845,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?: {
@@ -886,9 +901,13 @@ declare class TaskBuilder {
      * An Action Center human task. `recipient` may be an email (→ Type 2) or
      * `{ type, value }`. `inputs`/`outputs` declare the task's form fields — inputs
      * are read-only context the assignee sees, outputs are what they fill in.
-     * `labels` and `actionCatalogName` tag the task and name its action app.
+     * `app` names the Action App the task opens (`{ name, folder }`); compile
+     * binds it through an `app` name/folderPath pair keyed `<folder>.<name>`.
+     * `labels` tag the task. `actionCatalogName` names a task catalog, which is
+     * resolved in the app's deployment folder; it is not the app, and a name that
+     * folder does not hold fails the task when it opens.
      *
-     * @param spec - The human task: its `title`, `priority`, `recipient`, and the `inputs` / `outputs` its form shows and collects.
+     * @param spec - The human task: its `title`, `priority`, `recipient`, the Action `app`, and the `inputs` / `outputs` its form shows and collects.
      * @returns This builder, so calls chain.
      */
     action(spec?: {
@@ -899,6 +918,7 @@ declare class TaskBuilder {
             value: string;
         };
         labels?: string;
+        app?: ActionAppRef;
         actionCatalogName?: string;
         inputs?: ActionField[];
         outputs?: ActionField[];

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) {
@@ -332,13 +332,22 @@ class TaskBuilder {
      * An Action Center human task. `recipient` may be an email (→ Type 2) or
      * `{ type, value }`. `inputs`/`outputs` declare the task's form fields — inputs
      * are read-only context the assignee sees, outputs are what they fill in.
-     * `labels` and `actionCatalogName` tag the task and name its action app.
+     * `app` names the Action App the task opens (`{ name, folder }`); compile
+     * binds it through an `app` name/folderPath pair keyed `<folder>.<name>`.
+     * `labels` tag the task. `actionCatalogName` names a task catalog, which is
+     * resolved in the app's deployment folder; it is not the app, and a name that
+     * folder does not hold fails the task when it opens.
      *
-     * @param spec - The human task: its `title`, `priority`, `recipient`, and the `inputs` / `outputs` its form shows and collects.
+     * @param spec - The human task: its `title`, `priority`, `recipient`, the Action `app`, and the `inputs` / `outputs` its form shows and collects.
      * @returns This builder, so calls chain.
      */
     action(spec = {}) {
         this.setKind('action');
+        // The app is the task's resource, carried as its `ref` like every other
+        // bound resource, so the resource-ref rules in check and the binding pair
+        // in serialize both see it.
+        if (spec.app)
+            this._ref = { name: spec.app.name, folderPath: spec.app.folder };
         const recipient = typeof spec.recipient === 'string' ? { type: 2, value: spec.recipient } : spec.recipient;
         this._action = {
             title: spec.title,

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.js

@@ -292,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.
@@ -308,65 +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);
-        // 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 };
-        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
@@ -389,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)
@@ -415,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

@@ -344,11 +344,24 @@ 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
@@ -357,13 +370,13 @@ function bindingDefault(value, refs) {
  * (resource-identity.ts), so lift the sentinel back rather than the empty
  * default, which would recompile to the key `.<name>`.
  */
-function bindingFolder(value, refs) {
+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);
+    return bindingDefault(value, refs, owner, 'folderPath');
 }
 function selectNextStageByExit(plan, refs) {
     const raw = plan.metadata?.waitForHumanSelectNextStageDFConnector;
@@ -606,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))
@@ -628,6 +644,7 @@ function emitTaskKind(task, refs, library) {
             ['priority', data.priority && data.priority !== 'Medium' ? tsLiteral(data.priority) : undefined],
             ['recipient', recipient],
             ['labels', data.labels !== undefined ? tsLiteral(data.labels) : undefined],
+            ['app', actionApp(data, refs, task)],
             ['actionCatalogName', data.actionCatalogName !== undefined ? tsLiteral(data.actionCatalogName) : undefined],
             ['inputs', actionFields(data.inputs)],
             ['outputs', actionFields(data.outputs)],
@@ -663,6 +680,21 @@ function emitTaskKind(task, refs, library) {
     });
     return `.__UNRESOLVED_TASK_KIND__(${tsLiteral(kind)}, ${tsLiteral(data)})`;
 }
+/**
+ * The `app: { name, folder }` of an action task bound to its Action App, or
+ * undefined for one with no app. Dropping it lost the app binding on every
+ * round trip of a Studio Web plan (#1240).
+ */
+function actionApp(data, refs, task) {
+    if (data.name === undefined && data.folderPath === undefined)
+        return undefined;
+    const owner = `action task "${task.displayName ?? task.id ?? '?'}"`;
+    const name = bindingDefault(data.name, refs, owner, 'name');
+    const folder = bindingFolder(data.folderPath, refs, owner);
+    if (typeof name !== 'string' || !name || typeof folder !== 'string')
+        throw new Error(`${owner} names its app by neither a binding nor a literal name and folder.`);
+    return opts([['name', tsLiteral(name)], ['folder', tsLiteral(folder)]]);
+}
 /** A business-rule task `.businessRule()` can rebuild: v3 only. */
 function isAuthorableBusinessRule(task) {
     return task.type === 'business-rule' && task.data?.version === 'v3';
@@ -674,8 +706,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 = bindingFolder(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

@@ -30,7 +30,15 @@ export interface ResourceIdentity {
     /** The `default` of the `folderPath` binding row. */
     folderPath: string;
 }
-/** The binding identity of resource `name` authored in `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 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

@@ -25,9 +25,17 @@
  */
 export const SOLUTION_FOLDER = 'solution_folder';
 const SOLUTION_FOLDER_KEY_PREFIX = `${SOLUTION_FOLDER}.`;
-/** The binding identity of resource `name` authored in `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)
+    if (folder === SOLUTION_FOLDER || !folder.trim())
         return { resourceKey: `${SOLUTION_FOLDER_KEY_PREFIX}${name}`, folderPath: '' };
     return { resourceKey: `${folder}.${name}`, folderPath: folder };
 }