@uipath/maestro-builder-sdk 6.66.1 → 6.66.3

package/dist/case/serialize.d.ts

@@ -31,3 +31,19 @@ export interface ApplyPreservationOptions {
  * same operation compile performs with the payload the source carries.
  */
 export declare function applyPreservation(result: Record<string, unknown>, preservation: CaseJsonPreservation | undefined, options?: ApplyPreservationOptions): Record<string, unknown>;
+/**
+ * The payload with each stage label and task name an edit renamed rewritten to
+ * the one compiled, so a renamed stage or task keeps its ids and wire fields
+ * instead of reading as a delete plus an add. Stages left over on both sides
+ * pair by the most task names shared, then the fewest not shared, then in order
+ * when as many are left on each side; a task left over pairs with one in the
+ * same stage whose input and output rows have the same names, and a task gone
+ * from its stage that another stage now holds under the same name and rows
+ * moved there.
+ *
+ * `wanted` is the payload's side (identities read from the original plan),
+ * `compiled` this compile's. Per stage, `missing` tasks are the payload's that
+ * the compiled stage no longer names, `extra` tasks the compiled stage's that
+ * the payload does not.
+ */
+export declare function followRenames(result: Record<string, unknown>, preservation: CaseJsonPreservation): CaseJsonPreservation;

package/dist/case/serialize.js

@@ -9,7 +9,7 @@
  * name) are resolved here to the generated ids.
  */
 import { IdGen, offlineBindingSeed } from './ids.js';
-import { isUnrestorableSlotId } from './preserve.js';
+import { isUnrestorableSlotId, taskFingerprint } from './preserve.js';
 import { v31TaskSets } from './task-sets.js';
 import { camelizeName, defaultActionOutputVar } from './action-output-var.js';
 import { buildConnectorInputs, nestConnectorBody, replayInputsOf, transportHttpMethod } from '../core/connector-inputs.js';
@@ -23,6 +23,7 @@ import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, EXTERNAL_TASK_HYBRID_UNSUPPORTED, ex
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { isResourceLabelRefusal, resolveResourceRef, resourceIdentity } from './resource-identity.js';
 import { ownEntry } from '../core/own-entry.js';
+import { stableId } from '../core/stable-id.js';
 import { resolveSchemaVersion } from '../schema-version.js';
 import { caseJsonPreservation, caseJsonPreservationErrors, } from './preserve.js';
 import { businessEventProblems } from './business-event-shape.js';
@@ -30,6 +31,13 @@ import { readEventFilterLeaf, eventFilterTreeLeaf } from '../core/event-filters.
 import { responseJsonSchema } from '../core/connector-response-schema.js';
 import { ruleShapeProblems } from './rule-options.js';
 import { CompileRefusal } from '../core/compile-refusal.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) {
+    const id = stableId(`${elementId}${suffix}`);
+    resolver.elementSeededIds.push({ elementId, suffix, id });
+    return id;
+}
 /**
  * Condition `displayName` allocator.
  *
@@ -102,6 +110,7 @@ export function serialize(built, opts = {}) {
         escalationIdByName: new Map(),
         businessEvents: new Set((built.businessEvents ?? []).map((event) => event.name)),
         conditionName: conditionNamer(built),
+        elementSeededIds: [],
     };
     // Preallocate SLA + escalation ids (before any rule is emitted) so a
     // `sla-status-change` rule can resolve the `slaId`/`escalationId` it points at.
@@ -282,6 +291,7 @@ export function serialize(built, opts = {}) {
             }
             : {}),
     };
+    ELEMENT_SEEDED_IDS.set(result, resolver.elementSeededIds);
     const plan = stampConnectorConfigVersion(applyAuthorLayout(applyPreservation(result, caseJsonPreservation(built)), built.layout));
     // Last, over the finished document: V32 requires case-unique condition names,
     // and an author (or a decompiled pre-V32 plan) can repeat one. Rename the
@@ -396,6 +406,7 @@ export function applyPreservation(result, preservation, options = {}) {
     const errors = caseJsonPreservationErrors(preservation);
     if (errors.length)
         throw new CompileRefusal('PRESERVATION_COLLISION', `invalid Case JSON preservation payload: ${errors.join('; ')}`);
+    preservation = followRenames(result, preservation);
     applyPreservedIdentities(result, preservation);
     Object.assign(result, preservation.topLevel ?? {});
     Object.assign(result.metadata, preservation.metadata ?? {});
@@ -431,9 +442,15 @@ export function applyPreservation(result, preservation, options = {}) {
             const row = rows.find((candidate) => candidate.name === name);
             if (!row && options.overwrite)
                 continue;
+            // `custom` alone has nothing to mark when no row is written: an older SDK's
+            // companion for a variable an output writes, which this one migrates away.
+            if (!row && Object.keys(fields).every((field) => field === 'custom'))
+                continue;
             if (!row)
                 throw new CompileRefusal('PRESERVATION_TARGET_MISSING', `preserved variable "${name}" was not regenerated in variables.${lane}.`);
             for (const [field, value] of Object.entries(fields)) {
+                if (row[field] === value)
+                    continue;
                 if (!options.overwrite && Object.prototype.hasOwnProperty.call(row, field))
                     throw new CompileRefusal('PRESERVATION_FIELD_COLLISION', `preserved variable "${name}" field "${field}" collides with serializer-owned output.`);
                 row[field] = value;
@@ -524,14 +541,171 @@ export function applyPreservation(result, preservation, options = {}) {
         nodes.sort((left, right) => (order.get(String(left.id ?? '')) ?? Number.MAX_SAFE_INTEGER)
             - (order.get(String(right.id ?? '')) ?? Number.MAX_SAFE_INTEGER));
     }
+    // A stage the payload names that was not regenerated was deleted by the edit:
+    // its edges and canvas position go with it.
+    const nodeIds = new Set(result.nodes.map((node) => node.id));
+    const gone = new Set((preservation.identities?.stages ?? []).flatMap((stage) => (stage.id && !nodeIds.has(stage.id) ? [stage.id] : [])));
     if (preservation.edges !== undefined)
-        result.edges = preservation.edges;
+        result.edges = preservation.edges.filter((edge) => !gone.has(edge?.source) && !gone.has(edge?.target));
     if (preservation.layout !== undefined)
-        result.layout = preservation.layout;
+        result.layout = withoutLayoutNodes(preservation.layout, gone);
     else if (preservation.omitLayout)
         delete result.layout;
     return result;
 }
+function withoutLayoutNodes(layout, gone) {
+    const nodes = layout?.nodes;
+    if (!gone.size || !nodes || typeof nodes !== 'object' || !Object.keys(nodes).some((id) => gone.has(id)))
+        return layout;
+    return { ...layout, nodes: Object.fromEntries(Object.entries(nodes).filter(([id]) => !gone.has(id))) };
+}
+/**
+ * The payload with each stage label and task name an edit renamed rewritten to
+ * the one compiled, so a renamed stage or task keeps its ids and wire fields
+ * instead of reading as a delete plus an add. Stages left over on both sides
+ * pair by the most task names shared, then the fewest not shared, then in order
+ * when as many are left on each side; a task left over pairs with one in the
+ * same stage whose input and output rows have the same names, and a task gone
+ * from its stage that another stage now holds under the same name and rows
+ * moved there.
+ *
+ * `wanted` is the payload's side (identities read from the original plan),
+ * `compiled` this compile's. Per stage, `missing` tasks are the payload's that
+ * the compiled stage no longer names, `extra` tasks the compiled stage's that
+ * the payload does not.
+ */
+export function followRenames(result, preservation) {
+    const wanted = preservation.identities?.stages ?? [];
+    if (!wanted.length)
+        return preservation;
+    const compiled = (result.nodes ?? []).filter((node) => String(node.type ?? '').endsWith('Stage'));
+    const labelOf = (stage) => String(stage.data?.label ?? '');
+    const tasksOf = (stage) => (stage.data?.tasks ?? []).flat().filter((task) => task && typeof task === 'object');
+    const compiledLabels = new Set(compiled.map(labelOf));
+    const wantedLabels = new Set(wanted.map((stage) => stage.label));
+    const unmatchedCompiled = compiled.filter((stage) => !wantedLabels.has(labelOf(stage)));
+    const stageLabels = new Map();
+    const paired = new Set();
+    const unmatchedWanted = wanted.filter((stage) => !compiledLabels.has(stage.label));
+    // Ranked across every pair, so a deleted stage that shares one task name with
+    // a renamed stage cannot take it from the stage that shares more.
+    const stagePairs = unmatchedWanted.flatMap((stage, from) => {
+        const names = new Set((stage.tasks ?? []).flat().map((task) => task.name));
+        return unmatchedCompiled.flatMap((candidate, to) => {
+            const tasks = tasksOf(candidate);
+            const shared = tasks.filter((task) => names.has(String(task.displayName ?? ''))).length;
+            return shared ? [{ from, to, shared, unshared: names.size + tasks.length - 2 * shared }] : [];
+        });
+    });
+    stagePairs.sort((a, b) => b.shared - a.shared || a.unshared - b.unshared || a.from - b.from || a.to - b.to);
+    for (const { from, to } of stagePairs) {
+        if (stageLabels.has(unmatchedWanted[from].label) || paired.has(unmatchedCompiled[to]))
+            continue;
+        paired.add(unmatchedCompiled[to]);
+        stageLabels.set(unmatchedWanted[from].label, labelOf(unmatchedCompiled[to]));
+    }
+    const unpairedWanted = unmatchedWanted.filter((stage) => !stageLabels.has(stage.label));
+    const unpairedCompiled = unmatchedCompiled.filter((stage) => !paired.has(stage));
+    if (unpairedWanted.length === unpairedCompiled.length)
+        unpairedWanted.forEach((stage, index) => stageLabels.set(stage.label, labelOf(unpairedCompiled[index])));
+    const rowNames = (inputs, outputs) => JSON.stringify([inputs, outputs].map((rows) => (Array.isArray(rows) ? rows : []).map((row) => String(row?.name ?? ''))));
+    const nameOf = (task) => String(task.displayName ?? '');
+    const stageSides = wanted.map((stage) => {
+        const target = compiled.find((candidate) => labelOf(candidate) === (stageLabels.get(stage.label) ?? stage.label));
+        const tasks = (stage.tasks ?? []).flat();
+        const current = target ? tasksOf(target) : [];
+        const currentNames = new Set(current.map(nameOf));
+        const names = new Set(tasks.map((task) => task.name));
+        return { stage, target, missing: tasks.filter((task) => !currentNames.has(task.name)), extra: current.filter((task) => !names.has(nameOf(task))) };
+    });
+    const targeted = new Set(stageSides.map((side) => side.target));
+    const extraTasks = [
+        ...stageSides.flatMap(({ target, extra }) => (target ? extra.map((task) => ({ stage: labelOf(target), task })) : [])),
+        ...compiled.filter((stage) => !targeted.has(stage)).flatMap((stage) => tasksOf(stage).map((task) => ({ stage: labelOf(stage), task }))),
+    ];
+    const missingTasks = stageSides.flatMap(({ stage, missing }) => missing.map((task) => ({ stage: stage.label, task })));
+    const moves = new Map();
+    const claimed = new Set();
+    for (const { stage, task } of missingTasks) {
+        const rows = rowNames(task.inputs, task.outputs);
+        const to = extraTasks.filter((extra) => nameOf(extra.task) === task.name && rowNames(extra.task.data?.inputs, extra.task.data?.outputs) === rows);
+        if (to.length !== 1 || missingTasks.filter((other) => other.task.name === task.name).length !== 1)
+            continue;
+        if (!moves.has(stage))
+            moves.set(stage, new Map());
+        moves.get(stage).set(task.name, to[0].stage);
+        claimed.add(to[0].task);
+    }
+    const movedTo = (label, name) => moves.get(label)?.get(name);
+    const taskNames = new Map();
+    for (const side of stageSides) {
+        if (!side.target)
+            continue;
+        const missing = side.missing.filter((task) => !movedTo(side.stage.label, task.name));
+        const extra = side.extra
+            .filter((task) => !claimed.has(task))
+            .map((task) => ({ name: nameOf(task), rows: rowNames(task.data?.inputs, task.data?.outputs), task }));
+        // A deleted sibling can share a renamed task's rows, so the one whose content
+        // the renamed task still has wins, then the old name closest to the new one,
+        // then the earlier task.
+        const candidates = missing.flatMap((task, from) => extra.flatMap((candidate, to) => candidate.rows === rowNames(task.inputs, task.outputs)
+            ? [{ from, to, same: Number(task.fingerprint !== undefined && task.fingerprint === taskFingerprint(candidate.task)), score: nameAffinity(task.name, candidate.name) }]
+            : []));
+        candidates.sort((a, b) => b.same - a.same || b.score - a.score || a.from - b.from || a.to - b.to);
+        const renames = new Map();
+        const taken = new Set();
+        for (const { from, to } of candidates) {
+            if (renames.has(missing[from].name) || taken.has(to))
+                continue;
+            renames.set(missing[from].name, extra[to].name);
+            taken.add(to);
+        }
+        if (renames.size)
+            taskNames.set(side.stage.label, renames);
+    }
+    if (!stageLabels.size && !taskNames.size && !moves.size)
+        return preservation;
+    const stageName = (label) => stageLabels.get(label) ?? label;
+    const taskName = (label, name) => taskNames.get(label)?.get(name) ?? name;
+    const ref = (entry) => ({ ...entry, stage: movedTo(entry.stage, entry.task) ?? stageName(entry.stage), task: taskName(entry.stage, entry.task) });
+    const stages = wanted.map((stage) => ({
+        ...stage,
+        label: stageName(stage.label),
+        ...(stage.tasks
+            ? { tasks: stage.tasks.map((lane) => lane.filter((task) => !movedTo(stage.label, task.name)).map((task) => ({ ...task, name: taskName(stage.label, task.name) }))) }
+            : {}),
+    }));
+    for (const { stage: from, task } of missingTasks) {
+        const to = movedTo(from, task.name);
+        if (!to)
+            continue;
+        const target = stages.find((stage) => stage.label === to);
+        if (target)
+            target.tasks = [...(target.tasks ?? []), [task]];
+        else
+            stages.push({ label: to, tasks: [[task]] });
+    }
+    return {
+        ...preservation,
+        identities: {
+            ...preservation.identities,
+            stages,
+        },
+        ...(preservation.taskFields ? { taskFields: preservation.taskFields.map(ref) } : {}),
+        ...(preservation.omitTaskElementIds ? { omitTaskElementIds: preservation.omitTaskElementIds.map(ref) } : {}),
+        ...(preservation.omitStagePositions ? { omitStagePositions: preservation.omitStagePositions.map(stageName) } : {}),
+    };
+}
+/** How much of a renamed name survives: the longer of the shared prefix and the shared suffix. */
+function nameAffinity(before, after) {
+    let prefix = 0;
+    while (prefix < before.length && before[prefix] === after[prefix])
+        prefix++;
+    let suffix = 0;
+    while (suffix < before.length && suffix < after.length && before.at(-1 - suffix) === after.at(-1 - suffix))
+        suffix++;
+    return Math.max(prefix, suffix);
+}
 function applyPreservedIdentities(result, preservation) {
     const identities = preservation.identities;
     if (!identities)
@@ -543,11 +717,70 @@ function applyPreservedIdentities(result, preservation) {
         replacements.set(current.id, wanted);
         current.id = wanted;
     };
+    const nodes = result.nodes;
+    const stages = nodes.filter((node) => String(node.type).endsWith('Stage'));
+    const bagField = CASE_FORMAT_PROFILE.waitConnectorRuleBagField;
+    const ruleOutputRows = (conditions) => (conditions ?? []).flatMap((condition) => (condition?.rules ?? []).flat().flatMap((rule) => rule?.[bagField]?.outputs ?? []));
+    // Every output row id in the plan, task and rule rows alike, kept current as
+    // preserved ids are taken. Output ids are unique plan-wide (`claimOutputId`); a
+    // preserved id that another row already holds would undo that. Example: an
+    // older SDK wrote two action rows both `{ id: 'action', var: 'action' }`; this
+    // pass gives the second `action2`, and taking its preserved `action` would make
+    // it a duplicate.
+    const heldOutputIds = new Set();
+    for (const stage of stages) {
+        const rows = [
+            ...ruleOutputRows(stage.data?.entryConditions),
+            ...ruleOutputRows(stage.data?.exitConditions),
+            ...(stage.data?.tasks ?? []).flat().flatMap((task) => [...(task?.data?.outputs ?? []), ...ruleOutputRows(task?.entryConditions)]),
+        ];
+        for (const row of rows)
+            if (typeof row?.id === 'string')
+                heldOutputIds.add(row.id);
+    }
+    for (const row of ruleOutputRows(result.metadata?.caseExitRules))
+        if (typeof row?.id === 'string')
+            heldOutputIds.add(row.id);
+    const takeOutputRows = (outputRows, wantedRows) => {
+        // Match by name when unique on both sides, else by position.
+        const unique = (names, name) => names.filter((n) => n === name).length === 1;
+        const currentNames = outputRows.map((r) => r?.name);
+        const wantedNames = wantedRows.map((r) => r.name);
+        const named = new Set(wantedRows.filter((r) => unique(wantedNames, r.name) && unique(currentNames, r.name)).map((r) => r.name));
+        wantedRows.forEach((row, index) => {
+            const target = named.has(row.name)
+                ? outputRows.find((r) => r?.name === row.name)
+                // A positional match never takes a row a name match owns.
+                : named.has(outputRows[index]?.name) ? undefined : outputRows[index];
+            const currentId = target?.id;
+            // 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
+            // `=vars.<name>` reader, so the typed rule wins and the row migrates.
+            if (target && OWN_NAME_OUTPUT_ROWS.has(target) && row.id !== target.id)
+                return;
+            if (target && typeof row.id === 'string' && row.id !== currentId && heldOutputIds.has(row.id))
+                return;
+            take(target, row.id);
+            if (target && typeof row.id === 'string' && typeof currentId === 'string') {
+                heldOutputIds.delete(currentId);
+                heldOutputIds.add(row.id);
+            }
+            if (typeof currentId === 'string' && typeof row.id === 'string' && target?.value === currentId) {
+                target.value = row.id;
+            }
+        });
+    };
     const takeConditions = (current, wanted) => {
         (wanted ?? []).forEach((condition, index) => {
             const target = current?.[index];
             take(target, condition.id);
-            (condition.rules ?? []).forEach((group, groupIndex) => group.forEach((rule, ruleIndex) => take(target?.rules?.[groupIndex]?.[ruleIndex], rule.id)));
+            (condition.rules ?? []).forEach((group, groupIndex) => group.forEach((rule, ruleIndex) => {
+                const ruleTarget = target?.rules?.[groupIndex]?.[ruleIndex];
+                take(ruleTarget, rule.id);
+                if (rule.outputs)
+                    takeOutputRows(ruleTarget?.[bagField]?.outputs ?? [], rule.outputs);
+            }));
         });
     };
     const takeSlas = (current, wanted) => {
@@ -558,22 +791,8 @@ function applyPreservedIdentities(result, preservation) {
         });
     };
     take(result, identities.id);
-    const nodes = result.nodes;
     const triggerNodes = nodes.filter((node) => node.type === 'case-management:Trigger' || node.type === 'uipath.case.trigger');
     (identities.triggers ?? []).forEach((trigger, index) => take(triggerNodes[index], trigger.id));
-    const stages = nodes.filter((node) => String(node.type).endsWith('Stage'));
-    // Every task-output row id in the plan, kept current as preserved ids are
-    // taken. Output ids are unique plan-wide (`claimOutputId`); a preserved id that
-    // another row already holds would undo that. Example: an older SDK wrote two
-    // action rows both `{ id: 'action', var: 'action' }`; this pass gives the
-    // second `action2`, and taking its preserved `action` would make it a duplicate.
-    const heldOutputIds = new Set();
-    for (const stage of stages)
-        for (const lane of stage.data?.tasks ?? [])
-            for (const task of lane)
-                for (const row of task?.data?.outputs ?? [])
-                    if (typeof row?.id === 'string')
-                        heldOutputIds.add(row.id);
     for (const stageIdentity of identities.stages ?? []) {
         const stage = stages.find((candidate) => candidate.data?.label === stageIdentity.label);
         take(stage, stageIdentity.id);
@@ -585,36 +804,7 @@ function applyPreservedIdentities(result, preservation) {
             take(task, taskIdentity.id);
             takeConditions(task?.entryConditions, taskIdentity.entryConditions);
             (taskIdentity.inputs ?? []).forEach((row, index) => take(task?.data?.inputs?.[index], row.id));
-            const outputRows = task?.data?.outputs ?? [];
-            const wantedRows = taskIdentity.outputs ?? [];
-            // Match by name when unique on both sides, else by position.
-            const unique = (names, name) => names.filter((n) => n === name).length === 1;
-            const currentNames = outputRows.map((r) => r?.name);
-            const wantedNames = wantedRows.map((r) => r.name);
-            const named = new Set(wantedRows.filter((r) => unique(wantedNames, r.name) && unique(currentNames, r.name)).map((r) => r.name));
-            wantedRows.forEach((row, index) => {
-                const target = named.has(row.name)
-                    ? outputRows.find((r) => r?.name === row.name)
-                    // A positional match never takes a row a name match owns.
-                    : named.has(outputRows[index]?.name) ? undefined : outputRows[index];
-                const currentId = target?.id;
-                // 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
-                // `=vars.<name>` reader, so the typed rule wins and the row migrates.
-                if (target && OWN_NAME_OUTPUT_ROWS.has(target) && row.id !== target.id)
-                    return;
-                if (target && typeof row.id === 'string' && row.id !== currentId && heldOutputIds.has(row.id))
-                    return;
-                take(target, row.id);
-                if (target && typeof row.id === 'string' && typeof currentId === 'string') {
-                    heldOutputIds.delete(currentId);
-                    heldOutputIds.add(row.id);
-                }
-                if (typeof currentId === 'string' && typeof row.id === 'string' && target?.value === currentId) {
-                    target.value = row.id;
-                }
-            });
+            takeOutputRows(task?.data?.outputs ?? [], taskIdentity.outputs ?? []);
         }));
     }
     const metadata = result.metadata;
@@ -627,11 +817,12 @@ function applyPreservedIdentities(result, preservation) {
                 return;
             take(variables[lane]?.find((candidate) => candidate.name === row.name), row.id);
         });
+    const longestFirst = [...replacements].sort((a, b) => b[0].length - a[0].length);
     const replace = (value) => {
         if (replacements.has(value))
             return replacements.get(value);
         let replaced = value;
-        for (const [current, wanted] of [...replacements].sort((a, b) => b[0].length - a[0].length))
+        for (const [current, wanted] of longestFirst)
             replaced = replaced.replaceAll(current, wanted);
         return replaced;
     };
@@ -696,6 +887,33 @@ function applyPreservedIdentities(result, preservation) {
     rewrite(result);
     for (const { row, source } of preservedOutputSources)
         row.source = source;
+    // An id hashed from a generated element id is re-minted from the preserved one,
+    // wherever it is spelled, including inside a `=jsonString:` configuration.
+    const reseeded = new Map();
+    for (const entry of ELEMENT_SEEDED_IDS.get(result) ?? []) {
+        const elementId = replace(entry.elementId);
+        if (elementId !== entry.elementId)
+            reseeded.set(entry.id, stableId(`${elementId}${entry.suffix}`));
+    }
+    if (reseeded.size)
+        reseed(result, reseeded);
+}
+function reseed(value, ids) {
+    if (!value || typeof value !== 'object')
+        return;
+    const entries = Array.isArray(value) ? value.map((entry, index) => [index, entry]) : Object.entries(value);
+    for (const [key, entry] of entries) {
+        if (typeof entry !== 'string') {
+            reseed(entry, ids);
+            continue;
+        }
+        let next = entry;
+        for (const [from, to] of ids)
+            if (next.includes(from))
+                next = next.replaceAll(from, to);
+        if (next !== entry)
+            value[key] = next;
+    }
 }
 function emitVariables(vars, ids, triggerNodeByRef) {
     const inputs = [];
@@ -1091,7 +1309,7 @@ function resolvedSubscriptionBag(kind, spec, resolver, elementId, where) {
     const folder = folderBindingRef(resolver, spec.folder, connection, { attribute: 'folder', where, target });
     if (folder)
         context.push(io('folderKey', 'string', { value: `=bindings.${folder.id}` }));
-    context.push(io('method', 'string', {}), io('path', 'string', {}), io('objectName', 'string', { value: op.objectName ?? spec.event }), io('operation', 'string', { value: op.eventOperation ?? spec.event }), io('metadata', 'json', { body: subscriptionMetadata(rc, op, spec.filters ?? [], elementId) }));
+    context.push(io('method', 'string', {}), io('path', 'string', {}), io('objectName', 'string', { value: op.objectName ?? spec.event }), io('operation', 'string', { value: op.eventOperation ?? spec.event }), io('metadata', 'json', { body: subscriptionMetadata(rc, op, spec.filters ?? [], elementId, resolver) }));
     return {
         serviceType: kind === 'trigger' ? CASE_FORMAT_PROFILE.eventServiceType : CASE_FORMAT_PROFILE.waitConnectorServiceType,
         context,
@@ -1106,7 +1324,7 @@ function eventInput(where, elementId) {
         ? { name: 'body', type: 'json', target: 'body', body: { queryParams: where }, var: 'vbody', id: 'vbody', elementId }
         : { name: 'body', type: 'json', target: 'body', value: '', var: 'vbody', id: 'vbody', elementId };
 }
-function subscriptionMetadata(rc, op, filters, elementId) {
+function subscriptionMetadata(rc, op, filters, elementId, resolver) {
     const instanceParameters = {
         connectorKey: rc.connectorKey,
         objectName: op.objectName ?? rc.nodeType.split('.').pop(),
@@ -1131,7 +1349,7 @@ function subscriptionMetadata(rc, op, filters, elementId) {
             const { read } = judged;
             return {
                 ...eventFilterTreeLeaf(read),
-                uiId: stableUuid(`${elementId}:${read.field}:${String(read.value)}:${index}`),
+                uiId: elementSeededId(resolver, elementId, `:${read.field}:${String(read.value)}:${index}`),
             };
         }).map((leaf) => ({
             id: leaf.id,
@@ -1140,7 +1358,7 @@ function subscriptionMetadata(rc, op, filters, elementId) {
             uiId: leaf.uiId,
         })),
         groups: [],
-        uuId: stableUuid(`${elementId}:filters`),
+        uuId: elementSeededId(resolver, elementId, ':filters'),
     } : null;
     const configuration = {
         essentialConfiguration: {
@@ -1182,16 +1400,6 @@ function subscriptionMetadata(rc, op, filters, elementId) {
         },
     };
 }
-function stableUuid(seed) {
-    let h1 = 0x811c9dc5;
-    let h2 = 0x01000193;
-    for (let index = 0; index < seed.length; index++) {
-        h1 = (h1 ^ seed.charCodeAt(index)) * 0x01000193 >>> 0;
-        h2 = (h2 + seed.charCodeAt(index) * (index + 7)) >>> 0;
-    }
-    const hex = (value, length) => value.toString(16).padStart(8, '0').slice(0, length);
-    return `${hex(h1, 8)}-${hex(h2, 4)}-4${hex(h1 >>> 8, 3)}-8${hex(h2 >>> 8, 3)}-${hex(h1 ^ h2, 8)}${hex(h2, 4)}`;
-}
 // ─── Reference-mode task io-binding (data.inputs[] / data.outputs[]) ───────────
 //
 // Wire shape verified against a real `uip maestro case` caseplan (the io-binding

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

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

package/dist/core/process-resource.js

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

package/dist/core/refusals.d.ts

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

package/dist/core/refusals.js

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

package/dist/merge.js

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