@uipath/maestro-builder-sdk 6.70.6 → 6.70.7

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

@@ -18,20 +18,79 @@
 import { checkExpression } from '../core/expr-check.js';
 import { CompileRefusal } from '../core/compile-refusal.js';
 import { defaultActionOutputVar } from './action-output-var.js';
+import { lowerTaskOutputRefs, pickByName, pickOutputRow, taskOutputRefs, unresolvedTaskOutputRef } from './task-output-ref.js';
 const NOUN = 'case variable';
 const NAMESPACE = 'vars';
-function checkExpr(expr, where, roots, out) {
+/**
+ * The root a task-output reference stands in for while the rest of the
+ * expression is checked: `serialize` lowers the reference to the output's id,
+ * which only it knows, so the check reads it as a declared root.
+ */
+const TASK_OUTPUT_ROOT = '$taskOutput';
+/**
+ * The task kinds whose output rows are all authored in `.outputs()`: a
+ * reference to any other name on them names nothing. Every other kind also
+ * writes rows of its own (a connector's `response` / `Error`, a business
+ * rule's `output`, an action's form fields), so for those `build()` resolves
+ * the stage and the task, and `serialize` resolves the output against the rows
+ * it wrote.
+ */
+const AUTHORED_OUTPUT_KINDS = new Set(['process', 'agent', 'rpa', 'api-workflow', 'case-management', 'flow-process', 'function']);
+/** Why `ref` names no output in `built`, or `undefined` when it may name one. */
+function taskOutputRefProblem(built, ref) {
+    const stage = pickByName([...new Set(built.stages.map((s) => s.label))], ref.stage, (label) => [label]);
+    if (stage === undefined)
+        return `names no stage labelled ${JSON.stringify(ref.stage)}`;
+    if (stage === 'ambiguous')
+        return 'names a stage label that more than one stage answers to';
+    const tasks = built.stages.filter((s) => s.label === stage).flatMap((s) => s.lanes.flat());
+    const task = pickByName(tasks, ref.task, (t) => [t.name]);
+    if (task === undefined)
+        return `names no task ${JSON.stringify(ref.task)} in stage ${JSON.stringify(stage)}`;
+    if (task === 'ambiguous')
+        return `names a task that more than one task in stage ${JSON.stringify(stage)} answers to`;
+    if (!AUTHORED_OUTPUT_KINDS.has(task.kind))
+        return undefined;
+    // The rows `emitTaskOutput` writes: named after the source's last segment
+    // (a custom row after its variable), writing `var`.
+    const rows = (task.outputs ?? []).map((o) => ({
+        name: o.custom ? o.var : o.source.replace(/^=/, '').split('.').pop() || o.source,
+        var: o.var,
+    }));
+    const row = pickOutputRow(rows, ref.output);
+    if (row === undefined) {
+        const offered = rows.map((r) => JSON.stringify(r.name));
+        return `names no output of task ${JSON.stringify(task.name)}, whose outputs are ${offered.length ? offered.join(', ') : 'none'}`;
+    }
+    if (row === 'ambiguous')
+        return `names more than one output of task ${JSON.stringify(task.name)}; name it by the variable it writes instead`;
+    return undefined;
+}
+/** Every task-output reference in `value` that names nothing in `built`. */
+function checkTaskOutputRefs(built, value, where, out) {
+    if (typeof value !== 'string')
+        return;
+    for (const ref of taskOutputRefs(value)) {
+        const why = taskOutputRefProblem(built, ref);
+        if (why)
+            out.push({ level: 'error', code: 'TASK_OUTPUT_REF_UNRESOLVED', message: unresolvedTaskOutputRef(ref, why), where });
+    }
+}
+function checkExpr(built, expr, where, roots, out) {
     if (!expr)
         return;
-    for (const d of checkExpression(expr, { roots, noun: NOUN, namespace: NAMESPACE })) {
+    checkTaskOutputRefs(built, expr, where, out);
+    const lowered = lowerTaskOutputRefs(expr, () => TASK_OUTPUT_ROOT);
+    const scope = lowered === expr ? roots : new Set([...roots, TASK_OUTPUT_ROOT]);
+    for (const d of checkExpression(lowered, { roots: scope, noun: NOUN, namespace: NAMESPACE })) {
         out.push({ ...d, where });
     }
 }
 /** Every rule's `=js:` gate across an AND/OR rule matrix. */
-function checkRules(rules, where, roots, out) {
+function checkRules(built, rules, where, roots, out) {
     for (const group of rules ?? [])
         for (const r of group)
-            checkExpr(r.expression, where, roots, out);
+            checkExpr(built, r.expression, where, roots, out);
 }
 /** Every first-level expression problem in a built case, each stamped with its location. */
 export function checkCaseExpressions(built) {
@@ -58,21 +117,32 @@ export function checkCaseExpressions(built) {
         for (const o of t.eventOutputs ?? [])
             roots.add(o.var);
     const out = [];
-    built.slaRules.forEach((sla, i) => checkExpr(sla.expression, `case SLA #${i + 1}`, roots, out));
-    built.caseExit.forEach((ce, i) => checkRules(ce.rules, `case completion #${i + 1}`, roots, out));
+    built.slaRules.forEach((sla, i) => checkExpr(built, sla.expression, `case SLA #${i + 1}`, roots, out));
+    built.caseExit.forEach((ce, i) => checkRules(built, ce.rules, `case completion #${i + 1}`, roots, out));
     for (const stage of built.stages) {
         const at = `stage "${stage.label}"`;
         for (const ec of stage.entry)
-            checkRules(ec.rules, `${at} entry`, roots, out);
+            checkRules(built, ec.rules, `${at} entry`, roots, out);
         for (const xc of stage.exit)
-            checkRules(xc.rules, `${at} exit`, roots, out);
-        stage.slaRules.forEach((sla, i) => checkExpr(sla.expression, `${at} SLA #${i + 1}`, roots, out));
+            checkRules(built, xc.rules, `${at} exit`, roots, out);
+        stage.slaRules.forEach((sla, i) => checkExpr(built, sla.expression, `${at} SLA #${i + 1}`, roots, out));
         for (const lane of stage.lanes) {
             for (const task of lane) {
                 const tat = `task "${task.name}" in ${at}`;
-                checkExpr(task.skip, `${tat} skipWhen`, roots, out);
+                checkExpr(built, task.skip, `${tat} skipWhen`, roots, out);
+                // A value that is not a gate can carry a reference too: a task input, an
+                // action form input, a custom output. Only the reference is checked
+                // here (these values are not gates, so their other reads are not), so a
+                // bad one fails `build()` as it would in a gate, not only at compile.
+                for (const inp of task.inputs ?? [])
+                    checkTaskOutputRefs(built, inp.value, `${tat} input "${inp.name}"`, out);
+                for (const f of task.action?.inputs ?? [])
+                    checkTaskOutputRefs(built, f.value, `${tat} action input "${f.name}"`, out);
+                for (const o of task.outputs ?? [])
+                    if (o.custom)
+                        checkTaskOutputRefs(built, o.source, `${tat} output "${o.var}"`, out);
                 for (const ec of task.entry)
-                    checkRules(ec.rules, `${tat} entry`, roots, out);
+                    checkRules(built, ec.rules, `${tat} entry`, roots, out);
             }
         }
     }

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

@@ -99,6 +99,35 @@ export interface CaseRule extends RuleOpts {
  * @returns A rule to pass to `entryWhen` / `exitWhen` / `completeWhen`.
  */
 export declare function rule(type: CaseRuleType, opts?: RuleOpts): CaseRule;
+/**
+ * Read another task's output in place, in a `=js:` expression or a task input:
+ * `=vars.<id>` once compiled, where `<id>` is the id the plan gives that output.
+ * No case variable is needed, so a plan built from an SDD carries only the
+ * variables the SDD declares.
+ *
+ * It returns the SDD's own `$xref` marker, so an SDD cell that carries one
+ * can also be copied as written. The output is named by the
+ * result field it reads or by its key in `.outputs()`.
+ *
+ * @example
+ * **Pass one task's result to the next, and gate on it**
+ * ```ts
+ * casePlan('expense').stage('Stage 1', (s) => s
+ *   .task('Analyze', (t) => t.agent('Analyzer', { folder: 'Shared' })
+ *     .outputs({ AgentExpenseRequest: '=AgentExpenseRequest' }))
+ *   .task('Process', (t) => t.process('Processor', { folder: 'Shared' })
+ *     .inputs({ request: `=${taskOutput('Stage 1', 'Analyze', 'AgentExpenseRequest')}` })
+ *     .skipWhen(`=js:${taskOutput('Stage 1', 'Analyze', 'AgentExpenseRequest')}.amount > 1000`)))
+ * ```
+ * compiles the input to `=vars.AgentExpenseRequest` and the gate to
+ * `=js:vars.AgentExpenseRequest?.amount > 1000`.
+ *
+ * @param stage - The producing task's stage label.
+ * @param task - The producing task's name.
+ * @param output - The output: the result field it reads (`AgentExpenseRequest`, `response`) or its `.outputs()` key.
+ * @returns The reference, to place inside an expression string.
+ */
+export declare function taskOutput(stage: string, task: string, output: string): string;
 /**
  * A pure expression gate. The receiving condition slot supplies its canonical
  * event: `case-entered` for stage entry, `selected-tasks-completed` for stage
@@ -1219,9 +1248,21 @@ declare class TaskBuilder {
      * name equals the field — an SDD row `estimatedAge -> estimatedAge` is
      * `.var('estimatedAge', 'number')` plus
      * `.outputs({ estimatedAge: { source: '=estimatedAge', type: 'number' } })`.
-     * An output that keeps its field's name with no such declaration is the
-     * task's own (bare) output, with no root entry — until a second task writes
-     * the same variable, which makes both reassignments.
+     *
+     * An output that keeps its field's name (the key is the source's last
+     * segment: `AgentExpenseRequest: '=AgentExpenseRequest'`, or
+     * `app_id: '=response.app_id'` on a connector task) with no such declaration
+     * is the task's own (bare) output: it stays on the task (`id == var`) and
+     * writes no case variable. Two exceptions: a `.var()` of that name (the row
+     * then feeds it), and a second task with the same key, which makes one shared
+     * case variable that both write (reassigned rows plus a root entry). To keep
+     * a second task's output of the same field on its task, give it the
+     * Designer's suffixed key: `Result2: '=Result'` is its own bare output. This
+     * is the output an SDD lists with no `->` arrow. Read it elsewhere with
+     * {@link taskOutput | taskOutput('<stage>', '<task>', '<output>')} (or the
+     * SDD's `$xref` marker copied as written), which compiles to `vars.<id>`
+     * of that output, so a plan built from an SDD needs no case variable the SDD
+     * does not declare.
      *
      * Pass `{ assign, type }` for a **custom** output: the SDD's `x = expr` row.
      * When the task completes, the case variable is set to `assign` — a literal,

package/dist/case/case-sdk.js

@@ -1,6 +1,7 @@
 import { connector as makeConnector, subscriptionFrom, } from '../core/actions.js';
 import { isTriggerDescriptor } from '../core/connectors.js';
 import { checkCaseExpressions, CaseBuildError } from './case-expr-check.js';
+import { taskOutputMarker } from './task-output-ref.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS, recordAuthoredCaseVersion } from './format-profile.js';
 import { schemaVersionRefusal } from '../schema-version.js';
 import { CompileRefusal } from '../core/compile-refusal.js';
@@ -19,6 +20,37 @@ export { CaseBuildError } from './case-expr-check.js';
 export function rule(type, opts = {}) {
     return { rule: type, ...opts };
 }
+/**
+ * Read another task's output in place, in a `=js:` expression or a task input:
+ * `=vars.<id>` once compiled, where `<id>` is the id the plan gives that output.
+ * No case variable is needed, so a plan built from an SDD carries only the
+ * variables the SDD declares.
+ *
+ * It returns the SDD's own `$xref` marker, so an SDD cell that carries one
+ * can also be copied as written. The output is named by the
+ * result field it reads or by its key in `.outputs()`.
+ *
+ * @example
+ * **Pass one task's result to the next, and gate on it**
+ * ```ts
+ * casePlan('expense').stage('Stage 1', (s) => s
+ *   .task('Analyze', (t) => t.agent('Analyzer', { folder: 'Shared' })
+ *     .outputs({ AgentExpenseRequest: '=AgentExpenseRequest' }))
+ *   .task('Process', (t) => t.process('Processor', { folder: 'Shared' })
+ *     .inputs({ request: `=${taskOutput('Stage 1', 'Analyze', 'AgentExpenseRequest')}` })
+ *     .skipWhen(`=js:${taskOutput('Stage 1', 'Analyze', 'AgentExpenseRequest')}.amount > 1000`)))
+ * ```
+ * compiles the input to `=vars.AgentExpenseRequest` and the gate to
+ * `=js:vars.AgentExpenseRequest?.amount > 1000`.
+ *
+ * @param stage - The producing task's stage label.
+ * @param task - The producing task's name.
+ * @param output - The output: the result field it reads (`AgentExpenseRequest`, `response`) or its `.outputs()` key.
+ * @returns The reference, to place inside an expression string.
+ */
+export function taskOutput(stage, task, output) {
+    return taskOutputMarker(stage, task, output);
+}
 /**
  * Gate a condition slot only on case data without naming its default event.
  *
@@ -505,9 +537,21 @@ class TaskBuilder {
      * name equals the field — an SDD row `estimatedAge -> estimatedAge` is
      * `.var('estimatedAge', 'number')` plus
      * `.outputs({ estimatedAge: { source: '=estimatedAge', type: 'number' } })`.
-     * An output that keeps its field's name with no such declaration is the
-     * task's own (bare) output, with no root entry — until a second task writes
-     * the same variable, which makes both reassignments.
+     *
+     * An output that keeps its field's name (the key is the source's last
+     * segment: `AgentExpenseRequest: '=AgentExpenseRequest'`, or
+     * `app_id: '=response.app_id'` on a connector task) with no such declaration
+     * is the task's own (bare) output: it stays on the task (`id == var`) and
+     * writes no case variable. Two exceptions: a `.var()` of that name (the row
+     * then feeds it), and a second task with the same key, which makes one shared
+     * case variable that both write (reassigned rows plus a root entry). To keep
+     * a second task's output of the same field on its task, give it the
+     * Designer's suffixed key: `Result2: '=Result'` is its own bare output. This
+     * is the output an SDD lists with no `->` arrow. Read it elsewhere with
+     * {@link taskOutput | taskOutput('<stage>', '<task>', '<output>')} (or the
+     * SDD's `$xref` marker copied as written), which compiles to `vars.<id>`
+     * of that output, so a plan built from an SDD needs no case variable the SDD
+     * does not declare.
      *
      * Pass `{ assign, type }` for a **custom** output: the SDD's `x = expr` row.
      * When the task completes, the case variable is set to `assign` — a literal,

package/dist/case/decompile.js

@@ -11,6 +11,7 @@ import { isUnrestorableSlotId, taskFingerprint } from './preserve.js';
 import { isInSolutionKey, SOLUTION_FOLDER } from './resource-identity.js';
 import { offlineBindingLabel } from './ids.js';
 import { connectorPlaceholderKindOf } from './connector-placeholder.js';
+import { raiseTaskOutputReads, referableOutputIds } from './task-output-ref.js';
 const TASK_KIND_METHOD = {
     process: 'process',
     agent: 'agent',
@@ -1599,6 +1600,7 @@ function slugId(plan) {
 export function decompileWithDiagnostics(plan, options = {}) {
     const diagnostics = [];
     refuseUnsupportedAuthoring(plan);
+    plan = raiseTaskOutputRefs(plan);
     const preservation = collectPreservation(plan);
     const refs = buildRefs(plan, options.library, options.bestEffort ? diagnostics : undefined);
     const selectNextStage = selectNextStageByExit(plan, refs);
@@ -1677,6 +1679,35 @@ export function decompileWithDiagnostics(plan, options = {}) {
     const source = `import { ${imports.join(', ')} } from ${tsLiteral(options.importSpecifier ?? './case-sdk.js')};\n\n${diagnosticHeader}${out.toString()}\n`;
     return { source, diagnostics };
 }
+/**
+ * The plan with each read of a task output that recompiling could not keep,
+ * `vars.<output id>`, written as the task-output reference that names the same
+ * row (`vars.$xref('<stage>','<task>','<output>')`, what `taskOutput()` writes;
+ * builder-sdk#1241). Recompiling lowers it back to `vars.<id>` of that row,
+ * whatever id the row then gets. See `referableOutputIds` for which reads.
+ */
+function raiseTaskOutputRefs(plan) {
+    const variables = plan.variables ?? {};
+    const roots = new Set();
+    for (const lane of [variables.inputs, variables.outputs, variables.inputOutputs])
+        for (const entry of lane ?? [])
+            for (const name of [entry?.name, entry?.id])
+                if (typeof name === 'string')
+                    roots.add(name);
+    const byId = referableOutputIds(plan, roots);
+    if (!byId.size)
+        return plan;
+    const raise = (value) => {
+        if (typeof value === 'string')
+            return raiseTaskOutputReads(value, byId);
+        if (Array.isArray(value))
+            return value.map(raise);
+        if (value && typeof value === 'object')
+            return Object.fromEntries(Object.entries(value).map(([name, field]) => [name, raise(field)]));
+        return value;
+    };
+    return raise(plan);
+}
 export function decompile(plan, options = {}) {
     return decompileWithDiagnostics(plan, options).source;
 }

package/dist/case/serialize.js

@@ -37,6 +37,7 @@ import { implicitInArgBuiltTrigger, unboundInArgMessage } from './in-arg-binding
 import { jsonClone } from '../core/json-clone.js';
 import { taskShapeProblems } from './task-shape.js';
 import { connectorPlaceholderData, isConnectorPlaceholder } from './connector-placeholder.js';
+import { lowerTaskOutputRefs, planTaskOutputs, resolveInPlan, unresolvedTaskOutputRef } from './task-output-ref.js';
 /** The ids a serialize pass hashed from element ids, by the document it returned. */
 const ELEMENT_SEEDED_IDS = new WeakMap();
 function elementSeededId(resolver, elementId, suffix) {
@@ -404,8 +405,46 @@ function serializeCase(built, opts) {
     // repeats the way the platform's V31/V32.0.1 migrations would, so the file is
     // already what the platform reads (see rule-names.ts).
     dedupeConditionNames(plan);
+    // Over the finished document too: a task-output reference resolves to the id
+    // of the row it names, and the ids are only final here.
+    lowerPlanTaskOutputRefs(plan);
     return plan;
 }
+/**
+ * Lower every `vars.$xref('<stage>','<task>','<output>')` marker (what
+ * `taskOutput()` writes, and what an SDD cell carries) in the written plan to
+ * `vars.<id>` of the output row it names, as `uip maestro case sdd convert`
+ * does (builder-sdk#1241). A marker that names no output is refused: left in
+ * place it reads nothing at run time, and the default `validate` profile
+ * reports only that the marker survived.
+ */
+function lowerPlanTaskOutputRefs(plan) {
+    let tasks;
+    const lower = (text) => lowerTaskOutputRefs(text, (ref) => {
+        tasks ??= planTaskOutputs(plan);
+        const resolved = resolveInPlan(tasks, ref);
+        if ('why' in resolved)
+            throw new CompileRefusal('TASK_OUTPUT_REF_UNRESOLVED', unresolvedTaskOutputRef(ref, resolved.why));
+        // A stand-in exists only in collect mode, which writes no plan: the marker is
+        // left, and the stood-in task's own refusal is what `check` reports.
+        return 'standIn' in resolved ? undefined : resolved.variable;
+    });
+    const walk = (value) => {
+        if (typeof value === 'string')
+            return value.includes('$xref') ? lower(value) : value;
+        if (Array.isArray(value)) {
+            for (let i = 0; i < value.length; i++)
+                value[i] = walk(value[i]);
+        }
+        else if (value && typeof value === 'object') {
+            const record = value;
+            for (const key of Object.keys(record))
+                record[key] = walk(record[key]);
+        }
+        return value;
+    };
+    walk(plan);
+}
 /** The task types whose `data.context[]` carries an Integration Service activity configuration. */
 const CONNECTOR_CONFIG_TASK_TYPES = new Set([
     'execute-connector-activity',
@@ -866,6 +905,17 @@ function applyPreservedIdentities(result, preservation) {
                 row.value = wanted;
         });
     };
+    // Rows `reassignCarried` turned back into reassignments, and the variables
+    // they write: each needs its root companion (added below, before the root
+    // variable ids are restored).
+    const carriedCompanions = new Map();
+    const reassignCarried = (row, id) => {
+        row.id = id;
+        row.originalVar = id;
+        row.target = `=${id}`;
+        if (!carriedCompanions.has(row.var))
+            carriedCompanions.set(row.var, { id: row.var, name: row.var, type: row.type, elementId: 'root', custom: true });
+    };
     const nodes = result.nodes;
     const stages = nodes.filter((node) => String(node.type).endsWith('Stage'));
     const bagField = CASE_FORMAT_PROFILE.waitConnectorRuleBagField;
@@ -902,6 +952,19 @@ function applyPreservedIdentities(result, preservation) {
                 // A positional match never takes a row a name match owns.
                 : named.has(outputRows[index]?.name) ? undefined : outputRows[index];
             const currentId = target?.id;
+            // A nested own-name row (`app_id: '=response.app_id'`, written bare since
+            // builder-sdk#1241) whose carried id is not its variable is a row an
+            // SDK 6.67.1-era plan wrote reassigned, with a root companion that
+            // readers spell (`=vars.app_id`). It keeps that shape: the carried slot id
+            // goes on the row, `var` stays, and the companion comes back. Decided
+            // here, on identities `followRenames` has already paired, so a renamed
+            // task or stage keeps it too.
+            if (target && typeof row.id === 'string' && isCarriedNestedReassignment(target, row.id) && !heldOutputIds.has(row.id)) {
+                reassignCarried(target, row.id);
+                heldOutputIds.delete(currentId);
+                heldOutputIds.add(row.id);
+                return;
+            }
             // An own-name row's id IS its variable's name (`emitTaskOutput`). A
             // preserved id that differs — an `o<hash>` slot from a plan an older
             // SDK wrote — would rename the variable out from under every
@@ -957,6 +1020,20 @@ function applyPreservedIdentities(result, preservation) {
     takeConditions(metadata.caseExitRules, identities.caseExitRules);
     takeSlas(metadata.slaRules, identities.slaRules);
     const variables = result.variables;
+    if (carriedCompanions.size) {
+        const inputOutputs = (variables.inputOutputs ??= []);
+        const rootIds = new Set([...(variables.inputs ?? []), ...(variables.outputs ?? []), ...inputOutputs].map((entry) => entry?.id));
+        for (const [name, companion] of carriedCompanions)
+            if (!rootIds.has(name))
+                inputOutputs.push(companion);
+        // Any other row that writes the variable under its own name now aliases the
+        // root entry, the same rule `serialize` applies (`originalVar == id`).
+        for (const stage of stages)
+            for (const task of (stage.data?.tasks ?? []).flat())
+                for (const row of task?.data?.outputs ?? [])
+                    if (carriedCompanions.has(row?.var) && row.id === row.var && row.originalVar === undefined)
+                        row.originalVar = row.id;
+    }
     for (const [lane, rows] of Object.entries(identities.variables ?? {}))
         (rows ?? []).forEach((row) => {
             if (isUnrestorableSlotId(lane, row))
@@ -1722,13 +1799,16 @@ const OWN_NAME_OUTPUT_ROWS = new WeakSet();
  * One `data.outputs[]` row: `source` field → the `var` case variable. Two shapes,
  * as the Case Designer writes them:
  *
- * - **own name** — the output keeps its field's name (a top-level `source` whose
- *   field is the `var`, or the Designer's camelCase of it, either one optionally
+ * - **own name** — the output keeps its field's name (the `var` is the source's
+ *   last segment, or the Designer's camelCase of it, either one optionally
  *   with a numeric suffix: `=APIOutput1` into `APIOutput1`, `aPIOutput1` or
- *   `aPIOutput12`; see `keepsOwnName`). The row's `id` IS the `var`, with no
- *   `originalVar`: `{ id: 'APIOutput1', var: 'APIOutput1', target: '=APIOutput1' }`.
+ *   `aPIOutput12`, and `=response.app_id` into `app_id`; see `keepsOwnName`).
+ *   The row's `id` IS the `var`, with no `originalVar`:
+ *   `{ id: 'APIOutput1', var: 'APIOutput1', target: '=APIOutput1' }`. This is
+ *   the task-scoped output: it writes no case variable, and a later task reads
+ *   it in place, `=vars.<id>`, or by `taskOutput(stage, task, output)`.
  * - **reassigned** — the output feeds a differently named variable (`=age` into
- *   `estimatedAge`, or any nested `=Error.Message`). The row keeps its own minted
+ *   `estimatedAge`, `=Error.Message` into `errorMsg`). The row keeps its own minted
  *   slot `id`, points `var` at the case variable, and repeats the slot in
  *   `originalVar`, which is how the Designer recognises a reassignment.
  *
@@ -2277,12 +2357,42 @@ function claimOutputId(resolver, base) {
     resolver.outputIds.add(id);
     return id;
 }
+/**
+ * Whether `row` is a nested own-name output (a dotted `source` whose last
+ * segment keeps its name, written with `id == var`) and the carried plan gave
+ * it a different id, i.e. wrote it reassigned. See `applyPreservedIdentities`.
+ *
+ * An own-name row has two shapes, and both count: bare (no `originalVar`), and
+ * the alias of a root variable of the same name (`originalVar == id`), which is
+ * how it is written when a `.var()` declares that variable. Example: the
+ * phase5-1 business-rule fixture declares `riskBand` and carries
+ * `{ id: 'oMvpql9VW', var: 'riskBand', originalVar: 'oMvpql9VW' }`; it compiles
+ * as the alias `{ id: 'riskBand', originalVar: 'riskBand' }` and is a carried
+ * reassignment all the same. A row whose `originalVar` names another id is a
+ * reassignment already, and `id == var` rules it out above.
+ */
+function isCarriedNestedReassignment(row, carriedId) {
+    if (!row || row.custom === true || typeof row.id !== 'string' || row.id !== row.var)
+        return false;
+    if (row.originalVar !== undefined && row.originalVar !== row.id)
+        return false;
+    if (carriedId === row.id || typeof row.source !== 'string')
+        return false;
+    const path = row.source.replace(/^=/, '');
+    return path.includes('.') && keepsOwnName(row.var, path.split('.').pop() ?? '');
+}
 /** Whether a task output is written in the own-name shape (see `emitTaskOutput`). */
 function isOwnNameOutput(o) {
     if (o.custom)
         return false;
-    const path = o.source.replace(/^=/, '');
-    return !path.includes('.') && keepsOwnName(o.var, path);
+    // The field is the path's last segment, as the row's `name` is: a connector
+    // task's `app_id: '=response.app_id'` keeps its field's name exactly as
+    // `=APIOutput1` into `APIOutput1` does. `uip maestro case sdd convert` writes
+    // that bare row (`outputFor`: `{ id: 'app_id', var: 'app_id', source:
+    // '=response.app_id' }`), so it stays on the task with no root companion
+    // (builder-sdk#1241).
+    const field = o.source.replace(/^=/, '').split('.').pop() ?? '';
+    return keepsOwnName(o.var, field);
 }
 /**
  * Every variable a task in the plan writes under its own name: own-name task

package/dist/case/task-output-ref.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Reading another task's output in place: the SDD's `vars.$xref('<stage>',
+ * '<task>', '<output>')` marker, and `taskOutput()`, the typed way to write it
+ * (builder-sdk#1241).
+ *
+ * A task's own output is a variable of its own: the Case Designer saves it as
+ * `{ name: 'AgentExpenseRequest', id: 'agentExpenseRequest', var:
+ * 'agentExpenseRequest' }`, with no root `variables` entry, and a later task
+ * reads it as `=vars.agentExpenseRequest`. The id is the plan's, not the
+ * author's: it is unique across the plan, so a second task's `Action` output
+ * is `action2`. An SDD therefore names an output by where it is produced, and
+ * `uip maestro case sdd convert` lowers each marker to `vars.<output id>`
+ * (`sdd-convert/xrefs.ts`). Without the lowering here, an author had to copy
+ * the value into a case variable the SDD does not declare, and `validate
+ * --strict --sdd` refuses each one (`STRICT_SDD_VARIABLE_EXTRA`).
+ *
+ * The rule lives here so `check` (at `build()`) and `serialize` read a marker
+ * the same way. `build()` cannot see the ids, which `serialize` mints, so it
+ * resolves the stage and the task, and the output where the task's rows are
+ * all authored (a reference-mode task). `serialize` resolves every marker
+ * against the rows it wrote and refuses one that names no output.
+ */
+/** The marker's three arguments. */
+export interface TaskOutputRef {
+    stage: string;
+    task: string;
+    output: string;
+}
+/** An output row, as far as a reference to it is concerned. */
+export interface OutputRowKey {
+    /** The row's `name`: the result field it reads (`AgentExpenseRequest`, `response`). */
+    name?: string;
+    /** The variable the row writes. */
+    var?: string;
+}
+/** Each marker in `text`, in order, with where it sits. */
+export declare function taskOutputRefs(text: string): Array<TaskOutputRef & {
+    whole: string;
+    index: number;
+}>;
+/**
+ * Replace every marker in `text` with what `lower` returns for it. In a `=js:`
+ * expression, a marker followed by a property read gets the optional chain
+ * (`vars.<id>?.field`); any other value keeps the plain read (`vars.<id>.field`).
+ *
+ * @param text - The expression.
+ * @param lower - The variable a marker reads (`agentExpenseRequest`), or `undefined` to keep the marker.
+ */
+export declare function lowerTaskOutputRefs(text: string, lower: (ref: TaskOutputRef) => string | undefined): string;
+/**
+ * The one candidate `name` picks out: an exact match first, then a
+ * case-insensitive one (an SDD addresses a stage or an output in any case).
+ * `undefined` when none does; `'ambiguous'` when more than one does.
+ */
+export declare function pickByName<T>(items: readonly T[], name: string, names: (item: T) => Array<string | undefined>): T | 'ambiguous' | undefined;
+/**
+ * The row an output reference names among one task's rows: by the field it
+ * reads (`name`) or by the variable it writes (`var`).
+ */
+export declare function pickOutputRow<R extends OutputRowKey>(rows: readonly R[], output: string): R | 'ambiguous' | undefined;
+/** The refusal message for a marker that resolves to nothing. */
+export declare function unresolvedTaskOutputRef(ref: TaskOutputRef, why: string): string;
+/**
+ * The marker for a reference: `vars.$xref('<stage>','<task>','<output>')`,
+ * each argument single-quoted with its quotes and backslashes escaped. What
+ * `taskOutput()` returns, and what decompile writes back.
+ */
+export declare function taskOutputMarker(stage: string, task: string, output: string): string;
+/** One task's output rows in a written plan, under the names a reference uses. */
+export interface PlanTaskOutputs {
+    stage: string;
+    task: string;
+    rows: Array<OutputRowKey & {
+        id?: string;
+    }>;
+    /**
+     * A refused task's stand-in, in `check`'s collect mode (`data.standIn`): it
+     * wrote no rows, so a reference to it cannot be resolved against them.
+     */
+    standIn?: boolean;
+}
+/** Every stage task's output rows in a written caseplan, in document order. */
+export declare function planTaskOutputs(plan: unknown): PlanTaskOutputs[];
+/**
+ * What a reference reads in a written plan: the variable of the row it names
+ * (`vars.<id>`, or a custom row's `var`, which has no id), or why it names none.
+ */
+export declare function resolveInPlan(tasks: readonly PlanTaskOutputs[], ref: TaskOutputRef): {
+    variable: string;
+} | {
+    why: string;
+} | {
+    standIn: true;
+};
+/**
+ * Turn each `vars.<output id>` read in `text` that only a task-output reference
+ * can say back into `vars.$xref(…)`, for decompile. `byId` maps such an id to
+ * the reference that names it.
+ */
+export declare function raiseTaskOutputReads(text: string, byId: ReadonlyMap<string, TaskOutputRef>): string;
+/**
+ * The output ids a decompiled source can only read back by reference: a row
+ * whose id is not the variable it writes (a reassigned extract, a Designer row
+ * such as `{ id: 'oA1b2C3d4', var: 'AgentExpenseRequest' }`). Recompiling mints
+ * that id afresh, and no declaration makes `vars.<id>` readable, so a
+ * `vars.<id>` read in the plan goes back to the source as the reference that
+ * resolves to the same row. A read of an id that is also a variable (an
+ * own-name row, a root variable) is left as written. A row the reference
+ * could not name uniquely is left as written too.
+ */
+export declare function referableOutputIds(plan: unknown, rootNames: ReadonlySet<string>): Map<string, TaskOutputRef>;