@uipath/maestro-builder-sdk 5.2.0

package/dist/case/serialize.js

@@ -0,0 +1,1414 @@
+/**
+ * case/serialize — turn a BuiltCase (from the builder) into a real UiPath
+ * `caseplan.json` (schema V30, as defined by @uipath/case-schema / validated by
+ * `uip maestro case validate`).
+ *
+ * A case is a hierarchy, not a graph: the output has `edges: []` and expresses
+ * all flow through Stage `entryConditions`/`exitConditions` and the case-level
+ * `metadata.caseExitRules`. Symbolic references in rules (a stage label, a task
+ * name) are resolved here to the generated ids.
+ */
+import { IdGen } from './ids.js';
+import { transportHttpMethod } from '../config.js';
+import { refuseLookupToken } from '../core/lookups.js';
+import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
+import { resolveSchemaVersion } from '../schema-version.js';
+import { caseJsonPreservation, caseJsonPreservationErrors, } from './preserve.js';
+import { readEventFilter, eventFilterProblem, eventFilterTreeLeaf } from '../event-filters.js';
+/**
+ * Condition `displayName` allocator.
+ *
+ * Condition names must be unique across the WHOLE case: `uip maestro case
+ * validate` rejects a repeat as CASE_MGMT_RULE_NAME_DUPLICATE, at error
+ * severity, over a namespace spanning stage entry, stage exit and task entry
+ * conditions plus `metadata.caseExitRules`. (The validator does exempt the
+ * DESIGNER's own generated names — the `Entry rule <n>` / `Exit rule <n>` /
+ * `Completion rule <n>` families and a few singletons — which is exactly the
+ * allowlist the old constants missed: `Entry rule` was one token short of it and
+ * `Complete rule` was never in it. `check` mirrors that list; emitting genuinely
+ * unique names here means this side does not depend on it.)
+ *
+ * So a generated default is derived from the condition's owner rather than being
+ * a constant — with constants, a single stage was already enough to fail,
+ * because the stage's own entry rule and its task's entry rule both defaulted to
+ * "Entry rule".
+ *
+ * Authored names are reserved FIRST, so a generated default never steals a name
+ * the author spells out later in the chain, and are then returned untouched —
+ * renaming what an author wrote would be the worse surprise. A collision among
+ * authored names is left alone here and reported by `case check` (DUP_RULE_NAME).
+ */
+function conditionNamer(built) {
+    const taken = new Set();
+    const reserve = (name) => void (name && taken.add(name));
+    for (const c of built.caseExit)
+        reserve(c.displayName);
+    for (const stage of built.stages) {
+        for (const c of stage.entry)
+            reserve(c.displayName);
+        for (const c of stage.exit)
+            reserve(c.displayName);
+        for (const lane of stage.lanes)
+            for (const task of lane)
+                for (const c of task.entry)
+                    reserve(c.displayName);
+    }
+    return (authored, fallback) => {
+        if (authored)
+            return authored;
+        let name = fallback;
+        for (let n = 2; taken.has(name); n += 1)
+            name = `${fallback} ${n}`;
+        taken.add(name);
+        return name;
+    };
+}
+export function serialize(built, opts = {}) {
+    const ids = new IdGen();
+    const caseId = ids.caseId(built.id);
+    // ── First pass: allocate stage + task ids, build resolution maps ──
+    const resolver = {
+        stageIdByLabel: new Map(),
+        taskIdByKey: new Map(),
+        library: opts.library,
+        bindings: opts.bindings,
+        bindingSink: new Map(),
+        varCompanions: new Map(),
+        connectorOutputCounts: new Map(),
+        slaId: new Map(),
+        slaIdByName: new Map(),
+        escalationId: new Map(),
+        escalationIdByName: new Map(),
+        conditionName: conditionNamer(built),
+    };
+    // Preallocate SLA + escalation ids (before any rule is emitted) so a
+    // `sla-status-change` rule can resolve the `slaId`/`escalationId` it points at.
+    // Ids are deterministic (seeded on displayName when present, else position).
+    const prealloc = (slas, scope) => {
+        slas.forEach((sla, i) => {
+            const seed = sla.displayName ? `sla:${sla.displayName}` : `sla:${scope}:${i}`;
+            const id = ids.make('sla_', 8, seed);
+            resolver.slaId.set(sla, id);
+            if (sla.displayName)
+                resolver.slaIdByName.set(sla.displayName, id);
+            sla.escalations.forEach((e, j) => {
+                const eseed = e.displayName ? `esc:${e.displayName}` : `esc:${scope}:${i}:${j}`;
+                const eid = ids.make('esc_', 6, eseed);
+                resolver.escalationId.set(e, eid);
+                if (e.displayName)
+                    resolver.escalationIdByName.set(e.displayName, eid);
+            });
+        });
+    };
+    prealloc(built.slaRules, 'case');
+    built.stages.forEach((stage) => prealloc(stage.slaRules, stage.label));
+    const stageIds = [];
+    const taskIds = []; // [stageIndex][lane][taskIndex]
+    // Task displayNames must be unique across the whole case: the platform rejects
+    // duplicates (CASE_MGMT_STAGE_TASK_NAME_DUPLICATE, CRITICAL), and a bare
+    // `selected-tasks-completed` reference resolves against a single name→id map, so
+    // a duplicate would silently mis-resolve to the first task. Fail fast instead.
+    const seenTaskNames = new Set();
+    built.stages.forEach((stage, si) => {
+        const sid = ids.stageId(`stage:${stage.label}`);
+        if (resolver.stageIdByLabel.has(stage.label))
+            throw new Error(`duplicate stage label "${stage.label}".`);
+        resolver.stageIdByLabel.set(stage.label, sid);
+        stageIds.push(sid);
+        taskIds.push([]);
+        stage.lanes.forEach((lane, li) => {
+            taskIds[si].push([]);
+            lane.forEach((task) => {
+                if (seenTaskNames.has(task.name))
+                    throw new Error(`duplicate task displayName "${task.name}" — task names must be unique across the case.`);
+                seenTaskNames.add(task.name);
+                const tid = ids.taskId(`task:${stage.label}/${task.name}`);
+                taskIds[si][li].push(tid);
+                // Register both the qualified `Stage/Task` key and the (now unique) bare name.
+                resolver.taskIdByKey.set(`${stage.label}/${task.name}`, tid);
+                resolver.taskIdByKey.set(task.name, tid);
+            });
+        });
+    });
+    // ── Second pass: emit nodes ──
+    const nodes = [];
+    const triggerNodes = emitTriggers(built.triggers, ids, resolver);
+    nodes.push(...triggerNodes);
+    // Map each declared trigger to its emitted node (by object identity) so a
+    // trigger-bound In-arg can resolve `{ from }` to the node it wires onto.
+    const triggerNodeByRef = new Map();
+    built.triggers.forEach((t, i) => triggerNodeByRef.set(t, triggerNodes[i]));
+    built.stages.forEach((stage, si) => {
+        nodes.push(emitStage(stage, si, stageIds[si], taskIds[si], ids, resolver));
+    });
+    // ── Metadata (case-level) ──
+    const metadata = {
+        caseIdentifier: built.identifier,
+        caseAppEnabled: built.caseAppEnabled,
+        caseIdentifierType: built.identifierType,
+        publishVersion: CASE_FORMAT_PROFILE.publishVersion,
+    };
+    if (built.caseAppConfig) {
+        metadata.caseAppConfig = {
+            caseSummary: built.caseAppConfig.summary,
+            sections: built.caseAppConfig.sections.map((section, index) => ({
+                id: section.id ?? ids.make('section-', 6, `case-app:${index}:${section.title}`),
+                title: section.title,
+                details: JSON.stringify(section.details),
+            })),
+        };
+    }
+    if (built.allowAdhocOptionalStageTasks !== undefined) {
+        metadata.allowAdhocOptionalStageTasks = built.allowAdhocOptionalStageTasks;
+    }
+    const selectNextStage = built.stages.flatMap((stage) => stage.exit)
+        .filter((exit) => exit.selectNextStage !== undefined);
+    if (selectNextStage.length > 1)
+        throw new Error('select-next-stage can be configured on at most one stage exit per case.');
+    if (selectNextStage[0]?.selectNextStage) {
+        const { objectName, connector } = selectNextStage[0].selectNextStage;
+        if (selectNextStage[0].type !== 'wait-for-user')
+            throw new Error('select-next-stage requires an exit with type "wait-for-user".');
+        if (!objectName.trim())
+            throw new Error('select-next-stage objectName must be non-empty.');
+        const context = [];
+        if (connector) {
+            context.push(io('connectorKey', 'string', { value: connector.connectorKey }));
+            const connection = bindingRef(resolver, connector.connection, 'Connection', 'ConnectionId', `${connector.connectorKey} connection`);
+            if (connection) {
+                context.push(io('connection', 'string', { value: `=bindings.${connection.id}` }));
+                context.push(io('resourceKey', 'string', { value: connection.resourceKey }));
+            }
+            const folder = bindingRef(resolver, connector.folder, 'Connection', 'folderKey', 'FolderKey');
+            if (folder)
+                context.push(io('folderKey', 'string', { value: `=bindings.${folder.id}` }));
+        }
+        context.push(io('objectName', 'string', { value: objectName }));
+        if (connector)
+            context.push(io('operation', 'string', { value: connector.operation }));
+        metadata.waitForHumanSelectNextStageDFConnector = {
+            id: 'SelectNextStageConnector',
+            elementId: 'root-SelectNextStageConnector',
+            type: 'wait-for-connector',
+            displayName: 'Select next stage',
+            shouldRunOnlyOnce: false,
+            data: {
+                serviceType: CASE_FORMAT_PROFILE.waitConnectorServiceType,
+                context,
+                inputs: [],
+                outputs: [],
+                bindings: [],
+            },
+        };
+    }
+    if (built.caseExit.length) {
+        metadata.caseExitRules = built.caseExit.map((c, i) => emitCaseExit(c, i, ids, resolver));
+    }
+    if (built.slaRules.length) {
+        metadata.slaRules = built.slaRules.map((s, i, all) => emitSla(s, i, all.length, ids, resolver));
+    }
+    // Variables: declared vars + the readable companions that task outputs bound
+    // (collected during stage emission above). A declared var wins on a name clash.
+    const variables = emitVariables(built.vars, ids, triggerNodeByRef);
+    const inputOutputs = variables.inputOutputs;
+    const declared = new Set(inputOutputs.map((e) => e.id));
+    for (const [name, companion] of resolver.varCompanions)
+        if (!declared.has(name))
+            inputOutputs.push(companion);
+    const result = {
+        id: caseId,
+        name: built.name,
+        // Optional case description at the document root (schema-valid; the skill
+        // emits it too). Only written when set, so an undescribed case omits the key.
+        ...(built.description ? { description: built.description } : {}),
+        // The declared grammar version: `.schemaVersion()`'s when the author set
+        // one, else the profile's write version. Resolved here as well as in
+        // `check()` so a skipped static pass cannot stamp a version this build
+        // cannot back.
+        version: resolveSchemaVersion(CASE_SCHEMA_VERSIONS, built.version),
+        bindings: [...resolver.bindingSink.values()],
+        variables,
+        metadata,
+        nodes,
+        edges: [],
+        ...(CASE_FORMAT_PROFILE.layoutPolicy === 'sidecar'
+            ? {
+                layout: {
+                    nodes: Object.fromEntries(stageIds.map((id, index) => [id, { position: { x: 100 + index * 500, y: 200 } }])),
+                },
+            }
+            : {}),
+    };
+    return applyAuthorLayout(applyPreservation(result, caseJsonPreservation(built)), built.layout);
+}
+const CASE_NODE_LAYOUT_FIELDS = ['position', 'style', 'measured', 'width', 'height', 'zIndex'];
+/**
+ * Resolve author-level layout names only after preservation has restored foreign
+ * node identities. Authored fields then win field-by-field on the named entry;
+ * untouched preserved nodes, edges, fields, and ordering remain as received.
+ */
+function applyAuthorLayout(result, authored) {
+    const entries = [
+        ...Object.entries(authored?.stages ?? {}).map(([name, layout]) => ({ kind: 'stage', name, layout })),
+        ...Object.entries(authored?.triggers ?? {}).map(([name, layout]) => ({ kind: 'trigger', name, layout })),
+    ];
+    if (!entries.length)
+        return result;
+    const nodes = result.nodes;
+    const layoutValue = result.layout;
+    if (layoutValue !== undefined && (!layoutValue || typeof layoutValue !== 'object' || Array.isArray(layoutValue)))
+        throw new Error('case layout: preserved layout must be an object before authored entries can be applied.');
+    const existingLayout = (layoutValue ?? {});
+    const existingNodes = existingLayout.nodes;
+    if (existingNodes !== undefined && (!existingNodes || typeof existingNodes !== 'object' || Array.isArray(existingNodes)))
+        throw new Error('case layout: preserved layout.nodes must be an object before authored entries can be applied.');
+    const layoutNodes = { ...(existingNodes ?? {}) };
+    const layout = { ...existingLayout, nodes: layoutNodes };
+    for (const entry of entries) {
+        const matches = nodes.filter((node) => {
+            if (entry.kind === 'stage')
+                return String(node.type ?? '').endsWith('Stage') && node.data?.label === entry.name;
+            const trigger = node.type === 'case-management:Trigger' || node.type === 'uipath.case.trigger';
+            const label = node.data?.display?.label ?? node.data?.label;
+            return trigger && label === entry.name;
+        });
+        if (matches.length !== 1)
+            throw new Error(`case layout: ${entry.kind} "${entry.name}" matches ${matches.length} emitted nodes; expected exactly 1.`);
+        const nodeId = matches[0].id;
+        if (typeof nodeId !== 'string' || !nodeId)
+            throw new Error(`case layout: ${entry.kind} "${entry.name}" has no emitted node id.`);
+        const unknown = Object.keys(entry.layout).filter((field) => !CASE_NODE_LAYOUT_FIELDS.includes(field));
+        if (unknown.length)
+            throw new Error(`case layout: ${entry.kind} "${entry.name}" has unsupported field "${unknown[0]}".`);
+        const previous = layoutNodes[nodeId];
+        if (previous !== undefined && (!previous || typeof previous !== 'object' || Array.isArray(previous)))
+            throw new Error(`case layout: preserved entry for ${entry.kind} "${entry.name}" must be an object.`);
+        const merged = { ...(previous ?? {}) };
+        for (const field of CASE_NODE_LAYOUT_FIELDS)
+            if (entry.layout[field] !== undefined)
+                merged[field] = entry.layout[field];
+        if (Object.keys(merged).length)
+            layoutNodes[nodeId] = merged;
+    }
+    if (Object.keys(layoutNodes).length)
+        result.layout = layout;
+    return result;
+}
+function applyPreservation(result, preservation) {
+    if (!preservation)
+        return result;
+    const errors = caseJsonPreservationErrors(preservation);
+    if (errors.length)
+        throw new Error(`invalid Case JSON preservation payload: ${errors.join('; ')}`);
+    applyPreservedIdentities(result, preservation);
+    Object.assign(result, preservation.topLevel ?? {});
+    Object.assign(result.metadata, preservation.metadata ?? {});
+    const caseAppConfig = result.metadata.caseAppConfig;
+    if (caseAppConfig && preservation.caseAppConfigFields) {
+        for (const [field, value] of Object.entries(preservation.caseAppConfigFields.fields ?? {})) {
+            if (Object.prototype.hasOwnProperty.call(caseAppConfig, field))
+                throw new Error(`preserved caseAppConfig field "${field}" collides with serializer-owned output.`);
+            caseAppConfig[field] = value;
+        }
+        for (const entry of preservation.caseAppConfigFields.sections ?? []) {
+            const section = caseAppConfig.sections?.find((candidate) => candidate.id === entry.id);
+            if (!section)
+                continue;
+            for (const [field, value] of Object.entries(entry.fields)) {
+                if (Object.prototype.hasOwnProperty.call(section, field))
+                    throw new Error(`preserved Case App section "${entry.id}" field "${field}" collides with serializer-owned output.`);
+                section[field] = value;
+            }
+        }
+    }
+    const variables = result.variables;
+    for (const [lane, order] of Object.entries(preservation.variableOrder ?? {})) {
+        const rows = variables[lane] ?? [];
+        const byName = new Map(rows.map((row) => [String(row.name ?? ''), row]));
+        const ordered = (order ?? []).flatMap((name) => byName.get(name) ? [byName.get(name)] : []);
+        const named = new Set(order ?? []);
+        variables[lane] = [...ordered, ...rows.filter((row) => !named.has(String(row.name ?? '')))];
+    }
+    for (const [lane, byName] of Object.entries(preservation.variableFields ?? {})) {
+        const rows = variables[lane] ?? [];
+        for (const [name, fields] of Object.entries(byName ?? {})) {
+            const row = rows.find((candidate) => candidate.name === name);
+            if (!row)
+                throw new Error(`preserved variable "${name}" was not regenerated in variables.${lane}.`);
+            for (const [field, value] of Object.entries(fields)) {
+                if (Object.prototype.hasOwnProperty.call(row, field))
+                    throw new Error(`preserved variable "${name}" field "${field}" collides with serializer-owned output.`);
+                row[field] = value;
+            }
+        }
+    }
+    for (const [lane, byName] of Object.entries(preservation.legacyVariableDefaults ?? {})) {
+        const rows = variables[lane] ?? [];
+        for (const [name, value] of Object.entries(byName ?? {})) {
+            const row = rows.find((candidate) => candidate.name === name);
+            if (!row)
+                throw new Error(`legacy variable default "${name}" was not regenerated in variables.${lane}.`);
+            const encoded = JSON.stringify(value);
+            if (row.default !== encoded)
+                throw new Error(`legacy variable default "${name}" does not match the serializer-owned default.`);
+            row.default = value;
+        }
+    }
+    const stageNodes = result.nodes
+        .filter((node) => String(node.type ?? '').endsWith('Stage'));
+    for (const entry of preservation.taskFields ?? []) {
+        const stage = stageNodes.find((candidate) => candidate.data?.label === entry.stage);
+        const task = stage?.data?.tasks?.[entry.lane]?.find((candidate) => candidate.displayName === entry.task);
+        // A brownfield edit may deliberately delete a typed task or its stage. Its
+        // attached designer-only fields leave with that construct; surviving tasks
+        // still collide-refuse below instead of letting preservation overwrite
+        // serializer-owned output.
+        if (!task)
+            continue;
+        for (const [field, value] of Object.entries(entry.fields)) {
+            if (Object.prototype.hasOwnProperty.call(task, field)) {
+                // Agreement is not a collision. `elementId` moved from the preservation
+                // channel to serializer-owned, so a source generated by an older
+                // `case decompile` still carries it in its payload — and it reconstructs
+                // to the same `<stageId>-<taskId>`, because preservation pins the ids it
+                // is built from. Skipping the identical write keeps those sources
+                // compiling. A genuine disagreement still throws rather than letting the
+                // channel quietly overwrite typed output.
+                if (task[field] === value)
+                    continue;
+                throw new Error(`preserved task "${entry.stage}/${entry.task}" field "${field}" collides with serializer-owned output.`);
+            }
+            task[field] = value;
+        }
+    }
+    for (const entry of preservation.omitTaskElementIds ?? []) {
+        const stage = stageNodes.find((candidate) => candidate.data?.label === entry.stage);
+        const task = stage?.data?.tasks?.[entry.lane]?.find((candidate) => candidate.displayName === entry.task);
+        if (task)
+            delete task.elementId;
+    }
+    for (const label of preservation.omitStagePositions ?? []) {
+        const stage = stageNodes.find((candidate) => candidate.data?.label === label);
+        if (!stage)
+            continue;
+        delete stage.position;
+    }
+    const triggerNodes = result.nodes
+        .filter((node) => node.type === 'case-management:Trigger' || node.type === 'uipath.case.trigger');
+    for (const [index, fields] of (preservation.triggerDataFields ?? []).entries()) {
+        const trigger = triggerNodes[index];
+        if (!trigger)
+            throw new Error(`trigger ${index + 1} was not regenerated for preserved data fields.`);
+        Object.assign(trigger.data, fields);
+    }
+    if (preservation.nodes?.length) {
+        const nodes = result.nodes;
+        for (const entry of [...preservation.nodes].sort((a, b) => a.index - b.index))
+            nodes.splice(Math.min(entry.index, nodes.length), 0, entry.node);
+    }
+    if (preservation.nodeOrder?.length) {
+        const nodes = result.nodes;
+        const order = new Map(preservation.nodeOrder.map((id, index) => [id, index]));
+        nodes.sort((left, right) => (order.get(String(left.id ?? '')) ?? Number.MAX_SAFE_INTEGER)
+            - (order.get(String(right.id ?? '')) ?? Number.MAX_SAFE_INTEGER));
+    }
+    if (preservation.edges !== undefined)
+        result.edges = preservation.edges;
+    if (preservation.layout !== undefined)
+        result.layout = preservation.layout;
+    else if (preservation.omitLayout)
+        delete result.layout;
+    return result;
+}
+function applyPreservedIdentities(result, preservation) {
+    const identities = preservation.identities;
+    if (!identities)
+        return;
+    const replacements = new Map();
+    const take = (current, wanted) => {
+        if (!current || !wanted || typeof current.id !== 'string')
+            return;
+        replacements.set(current.id, wanted);
+        current.id = wanted;
+    };
+    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)));
+        });
+    };
+    const takeSlas = (current, wanted) => {
+        (wanted ?? []).forEach((sla, index) => {
+            const target = current?.[index];
+            take(target, sla.id);
+            (sla.escalations ?? []).forEach((entry, escalationIndex) => take(target?.escalationRule?.[escalationIndex], entry.id));
+        });
+    };
+    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'));
+    for (const stageIdentity of identities.stages ?? []) {
+        const stage = stages.find((candidate) => candidate.data?.label === stageIdentity.label);
+        take(stage, stageIdentity.id);
+        takeConditions(stage?.data?.entryConditions, stageIdentity.entryConditions);
+        takeConditions(stage?.data?.exitConditions, stageIdentity.exitConditions);
+        takeSlas(stage?.data?.slaRules, stageIdentity.slaRules);
+        (stageIdentity.tasks ?? []).forEach((lane, laneIndex) => lane.forEach((taskIdentity) => {
+            const task = stage?.data?.tasks?.[laneIndex]?.find((candidate) => candidate.displayName === taskIdentity.name);
+            take(task, taskIdentity.id);
+            takeConditions(task?.entryConditions, taskIdentity.entryConditions);
+            (taskIdentity.inputs ?? []).forEach((row, index) => take(task?.data?.inputs?.[index], row.id));
+            (taskIdentity.outputs ?? []).forEach((row, index) => {
+                const target = task?.data?.outputs?.[index];
+                const currentId = target?.id;
+                take(target, row.id);
+                if (typeof currentId === 'string' && typeof row.id === 'string' && target?.value === currentId) {
+                    target.value = row.id;
+                }
+            });
+        }));
+    }
+    const metadata = result.metadata;
+    takeConditions(metadata.caseExitRules, identities.caseExitRules);
+    takeSlas(metadata.slaRules, identities.slaRules);
+    const variables = result.variables;
+    for (const [lane, rows] of Object.entries(identities.variables ?? {}))
+        (rows ?? []).forEach((row) => take(variables[lane]?.find((candidate) => candidate.name === row.name), row.id));
+    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))
+            replaced = replaced.replaceAll(current, wanted);
+        return replaced;
+    };
+    const referenceFields = new Set([
+        'elementId', 'selectedStageId', 'selectedStageIds', 'selectedTasksIds', 'slaId', 'escalationId',
+        'originalVar', 'var', 'source', 'target',
+    ]);
+    const preservedOutputSources = [];
+    for (const node of nodes) {
+        if (String(node.type ?? '').endsWith('Stage')) {
+            for (const lane of node.data?.tasks ?? []) {
+                for (const task of lane) {
+                    for (const row of task.data?.outputs ?? []) {
+                        if (Object.prototype.hasOwnProperty.call(row, 'source')) {
+                            preservedOutputSources.push({ row, source: row.source });
+                        }
+                    }
+                }
+            }
+            continue;
+        }
+        if (node.type === 'case-management:Trigger' || node.type === 'uipath.case.trigger') {
+            const bag = node.type === 'uipath.case.trigger' ? node.data?.inputs : node.data?.uipath;
+            for (const row of bag?.outputs ?? []) {
+                if (typeof row.source === 'string' && !row.source.startsWith('=vars.')) {
+                    preservedOutputSources.push({ row, source: row.source });
+                }
+            }
+        }
+    }
+    const rewrite = (value, field) => {
+        if (Array.isArray(value)) {
+            value.forEach((entry, index) => {
+                if (typeof entry === 'string' && field && referenceFields.has(field))
+                    value[index] = replace(entry);
+                else
+                    rewrite(entry, field);
+            });
+            return;
+        }
+        if (!value || typeof value !== 'object')
+            return;
+        for (const [name, entry] of Object.entries(value)) {
+            if (typeof entry === 'string' && referenceFields.has(name))
+                value[name] = replace(entry);
+            else
+                rewrite(entry, name);
+        }
+    };
+    rewrite(result);
+    for (const { row, source } of preservedOutputSources)
+        row.source = source;
+}
+function emitVariables(vars, ids, triggerNodeByRef) {
+    const inputs = [];
+    const outputs = [];
+    const inputOutputs = [];
+    /**
+     * The root `inputOutputs` COMPANION — `id` = the variable's NAME (not its slot
+     * id) — is what an expression's `=js:vars.<name>` resolves against: the platform
+     * reads a variable by name from `nodes[root].inputOutputs`, and validates a
+     * reference to nothing (`vars.<name> does not exist`). Emitting it for every
+     * declared variable is the fix for the row-83 SDK-DEFECT — before this, a
+     * `.var()` / `.output()` companion carried `id: v<hash>`, so no gate could read
+     * it and mid-flight state had to be smuggled in as a trigger input to be
+     * readable at all. `elementId: 'root'` is the case root, which the trigger-bound
+     * In-arg path (below) mirrors with the trigger node's own id.
+     */
+    // A structured (object/array) var persists as `type: 'jsonSchema'` with the shape
+    // in a JSON-schema `body` (mirrored into `_jsonSchema`, per the platform recipe).
+    const jsonSchemaFields = (vd) => vd.type === 'jsonSchema' && vd.body !== undefined ? { body: vd.body, _jsonSchema: vd.body } : {};
+    const encodedDefault = (vd) => {
+        if (vd.default === undefined)
+            return {};
+        if (typeof vd.default === 'string')
+            return { default: vd.default };
+        const value = JSON.stringify(vd.default);
+        if (value === undefined)
+            throw new TypeError(`Case variable "${vd.name}" has a default that cannot be JSON encoded.`);
+        return { default: value };
+    };
+    const readableCompanion = (vd) => ({
+        id: vd.name,
+        name: vd.name,
+        type: vd.type,
+        ...encodedDefault(vd),
+        ...jsonSchemaFields(vd),
+        elementId: 'root',
+    });
+    for (const vd of vars) {
+        const slotId = ids.make('v', 8, `var:${vd.name}`);
+        const entry = {
+            id: slotId,
+            name: vd.name,
+            type: vd.type,
+            ...encodedDefault(vd),
+        };
+        Object.assign(entry, jsonSchemaFields(vd));
+        if (vd.direction === 'in' && vd.sourceTrigger) {
+            // Trigger-bound In-arg: formal slot + companion + a bridge on the trigger
+            // node that copies the slot into the companion at fire (see the skill's
+            // variables/io-binding + global-vars § In argument). Its companion is keyed
+            // to the trigger node, so it does not also take a root companion.
+            const node = triggerNodeByRef.get(vd.sourceTrigger);
+            if (!node)
+                throw new Error(`In-arg "${vd.name}" is bound via { from } to a trigger that was not added with .trigger(...).`);
+            entry.default = vd.default === undefined ? '' : encodedDefault(vd).default;
+            entry.elementId = node.id;
+            inputs.push(entry);
+            inputOutputs.push({ id: vd.name, name: vd.name, type: vd.type, elementId: node.id, ...jsonSchemaFields(vd) });
+            appendTriggerBridge(node, { name: vd.name, type: vd.type, source: `=vars.${slotId}`, var: vd.name });
+        }
+        else if (vd.direction === 'in') {
+            inputs.push(entry); // bare declaration (unbound In-arg; readable only via a trigger)
+        }
+        else if (vd.direction === 'out') {
+            outputs.push(entry); // formal declaration
+            inputOutputs.push(readableCompanion(vd)); // …made readable as `vars.<name>`
+        }
+        else {
+            // inout: the root companion IS its declaration (nothing references the slot).
+            inputOutputs.push(readableCompanion(vd));
+        }
+    }
+    const out = { inputOutputs };
+    if (inputs.length)
+        out.inputs = inputs;
+    if (outputs.length)
+        out.outputs = outputs;
+    return out;
+}
+/**
+ * Append an In-arg bridge to a trigger node's profile-owned payload. A manual
+ * trigger has no payload (its signature) — create `{ outputs: [] }` (with
+ * NO `serviceType`, so it stays manual) before appending.
+ */
+function appendTriggerBridge(node, bridge) {
+    const data = (node.data ?? (node.data = {}));
+    const bagField = CASE_FORMAT_PROFILE.triggerBagField;
+    const bag = (data[bagField] ?? (data[bagField] = { outputs: [] }));
+    if (!Array.isArray(bag.outputs))
+        bag.outputs = [];
+    bag.outputs.push(bridge);
+}
+/**
+ * Emit the case's trigger nodes. Empty → the default single manual `trigger_1`
+ * (back-compat). Otherwise one profile-owned trigger node per declared trigger:
+ * the first is `trigger_1` with no `parentElement` (the platform hydrates layout);
+ * the rest get a stable id + `parentElement`. A timer carries the profile-owned
+ * trigger bag; a manual omits the bag entirely (its signature).
+ */
+function emitTriggers(triggers, ids, resolver) {
+    const list = triggers.length ? triggers : [{ kind: 'manual' }];
+    return list.map((t, i) => {
+        const triggerId = i === 0 ? 'trigger_1' : ids.make('trigger_', 6, `trigger:${i}:${t.name ?? t.kind}`);
+        const data = {};
+        if (i > 0)
+            data.parentElement = { id: 'root', type: 'case-management:root' };
+        if (CASE_FORMAT_PROFILE.triggerTypeVersion)
+            data.typeVersion = CASE_FORMAT_PROFILE.triggerTypeVersion;
+        const label = t.name ?? `Trigger ${i + 1}`;
+        if (CASE_FORMAT_PROFILE.triggerLabelField === 'display')
+            data.display = { label };
+        else
+            data.label = label;
+        if (t.description)
+            data.description = t.description;
+        if (t.kind === 'timer') {
+            data[CASE_FORMAT_PROFILE.triggerBagField] = {
+                timerType: 'timeCycle',
+                timeCycle: t.timeCycle,
+                serviceType: CASE_FORMAT_PROFILE.timerServiceType,
+            };
+        }
+        else if (t.kind === 'event') {
+            // With no subscription this remains the byte-identical, serviceType-only
+            // placeholder. A subscription resolves through the same library/binding
+            // machinery as connector tasks and wait-for-connector bags.
+            const bag = t.eventSubscription
+                ? resolvedSubscriptionBag('trigger', t.eventSubscription, resolver, triggerId)
+                : { serviceType: CASE_FORMAT_PROFILE.eventServiceType };
+            if (t.eventOutputs?.length) {
+                const outputs = t.eventOutputs.map((o) => {
+                    const field = o.source.replace(/^=/, '').split('.').pop() || o.source;
+                    if (!resolver.varCompanions.has(o.var))
+                        resolver.varCompanions.set(o.var, { id: o.var, name: o.var, type: o.type, elementId: 'root', custom: true });
+                    return { name: field, var: o.var, source: o.source, type: o.type, value: o.var };
+                });
+                bag.outputs = [...(bag.outputs ?? []), ...outputs];
+            }
+            data[CASE_FORMAT_PROFILE.triggerBagField] = bag;
+        }
+        return {
+            id: triggerId,
+            [CASE_FORMAT_PROFILE.nodeTypeField]: CASE_FORMAT_PROFILE.triggerNodeType,
+            data,
+        };
+    });
+}
+function emitStage(stage, si, stageId, laneTaskIds, ids, resolver) {
+    const data = {
+        [CASE_FORMAT_PROFILE.stageLabelField]: stage.label,
+        parentElement: { id: 'root', type: 'case-management:root' },
+        isInvalidDropTarget: false,
+        isPendingParent: false,
+        tasks: stage.lanes.map((lane, li) => lane.map((task, ti) => emitTask(task, stage.label, laneTaskIds[li][ti], ids, resolver))),
+    };
+    if (stage.description)
+        data.description = stage.description;
+    if (stage.required !== undefined)
+        data.isRequired = stage.required;
+    if (stage.entry.length || stage.exception) {
+        data.entryConditions = stage.entry.map((c, i) => emitEntry(c, `${stage.label}:entry:${i}`, stageId, stage.label, ids, resolver));
+    }
+    if (stage.exit.length || stage.exception) {
+        data.exitConditions = stage.exit.map((c, i) => emitExit(c, `${stage.label}:exit:${i}`, stageId, stage.label, ids, resolver));
+    }
+    if (stage.slaRules.length) {
+        data.slaRules = stage.slaRules.map((s, i, all) => emitSla(s, i, all.length, ids, resolver));
+    }
+    const nodeType = stage.exception && CASE_FORMAT_PROFILE.exceptionStageField === CASE_FORMAT_PROFILE.nodeTypeField
+        ? CASE_FORMAT_PROFILE.exceptionStageValue
+        : CASE_FORMAT_PROFILE.stageNodeType;
+    if (stage.exception && CASE_FORMAT_PROFILE.exceptionStageField === 'data.stageType')
+        data.stageType = CASE_FORMAT_PROFILE.exceptionStageValue;
+    return {
+        id: stageId,
+        [CASE_FORMAT_PROFILE.nodeTypeField]: nodeType,
+        ...(CASE_FORMAT_PROFILE.layoutPolicy === 'inline' ? { position: { x: 100 + si * 500, y: 200 } } : {}),
+        data,
+    };
+}
+function emitTask(task, stageLabel, taskId, ids, resolver) {
+    const type = task.kind === 'connector' ? CASE_FORMAT_PROFILE.connectorActivityNodeType : task.kind;
+    const node = { id: taskId, displayName: task.name, [CASE_FORMAT_PROFILE.nodeTypeField]: type };
+    const stageId = resolver.stageIdByLabel.get(stageLabel);
+    node.data = taskData(task, resolver, taskId, stageId, ids);
+    // Every task carries `elementId: "<stageId>-<taskId>"`, the identity the
+    // converter matches a task's io rows against:
+    //
+    //   const outputs = taskOutputs.filter(
+    //     (output) => task.elementId === output.elementId && !!output.id?.length);
+    //
+    // …in `collectCaseTaskOutputGroups`, which feeds `getAllTasksOutputVariables`
+    // and `collectOverlayOutputs`. The io ROWS have always carried the value (see
+    // `taskData` below), so leaving it off the task made that filter compare
+    // `undefined` against the row's id, drop every match, and emit no
+    // `uipath:output` bridge — a declared `.outputs()` became inert at runtime
+    // while `validate` reported only a warning (TASK_MISSING_ELEMENT_ID).
+    //
+    // Emitted for every kind, not just those carrying io: that is what the modern
+    // designer writes (every task in the V27 corpus has one, always this
+    // spelling), and it is provably inert where nothing reads it — stamping it on
+    // a bare wait-for-timer leaves the converter's BPMN and rules byte-identical.
+    node.elementId = `${stageId}-${taskId}`;
+    if (task.runOnce !== undefined)
+        node.shouldRunOnlyOnce = task.runOnce;
+    if (task.required !== undefined)
+        node.isRequired = task.required;
+    if (task.skip)
+        node.skipCondition = task.skip;
+    if (task.description)
+        node.description = task.description;
+    if (task.entry.length) {
+        node.entryConditions = task.entry.map((c, i) => emitTaskEntry(c, `${stageLabel}/${task.name}:entry:${i}`, stageId, task.name, ids, resolver));
+    }
+    return node;
+}
+function taskData(task, resolver, taskId, stageId, ids) {
+    switch (task.kind) {
+        case 'process':
+        case 'agent':
+        case 'rpa':
+        case 'api-workflow':
+        // A `case-management` (sub-case) task invokes another published case, and its
+        // data shape is the same reference-mode `RunProcessTaskData` — so passing data
+        // into the child (`data.inputs[]`) and reading results back (`data.outputs[]`)
+        // uses the identical io-binding wire as the other reference tasks (Gap F).
+        case 'case-management':
+        case 'flow-process': {
+            // Reference-mode task, plus optional io-binding: input params and output
+            // extractions (`data.inputs[]` / `data.outputs[]`). Each row's `elementId`
+            // is "<stageId>-<taskId>"; an output also registers a root `inputOutputs`
+            // companion so `=vars.<var>` resolves downstream.
+            if (!task.ref)
+                return {};
+            const data = { name: task.ref.name, folderPath: task.ref.folderPath };
+            const elementId = `${stageId}-${taskId}`;
+            if (task.inputs?.length)
+                data.inputs = task.inputs.map((inp, i) => emitTaskInput(inp, elementId, ids, `${elementId}:in:${i}:${inp.name}`));
+            if (task.outputs?.length)
+                data.outputs = task.outputs.map((o, i) => emitTaskOutput(o, elementId, ids, `${elementId}:out:${i}:${o.var}`, resolver));
+            return data;
+        }
+        case 'action': {
+            const a = task.action ?? {};
+            const data = {};
+            if (a.title)
+                data.taskTitle = a.title;
+            data.priority = a.priority ?? 'Medium';
+            if (a.recipient) {
+                data.assignmentCriteria = 'user';
+                data.recipient = { Type: a.recipient.type, Value: a.recipient.value };
+            }
+            if (a.labels)
+                data.labels = a.labels;
+            if (a.actionCatalogName)
+                data.actionCatalogName = a.actionCatalogName;
+            // HITL form fields: inputs are read-only context the assignee sees, outputs
+            // are what they fill in. Each is a schema `InputOutput` row.
+            if (a.inputs?.length)
+                data.inputs = a.inputs.map((field) => emitActionField(field));
+            if (a.outputs?.length) {
+                data.outputs = a.outputs.map((field) => emitActionField(field, `${stageId}-${taskId}`, resolver));
+            }
+            return data;
+        }
+        case 'connector':
+            return connectorTaskData(task.connector, resolver, taskId);
+        case 'external-agent':
+        case 'external-workflow':
+            return externalTaskData(task.kind, task.external, resolver);
+        case 'wait-for-timer': {
+            if (task.timer?.duration)
+                return { timerType: 'timeDuration', timeDuration: task.timer.duration };
+            if (task.timer?.date)
+                return { timerType: 'timeDate', timeDate: task.timer.date };
+            if (task.timer?.cycle)
+                return { timerType: 'timeCycle', timeCycle: task.timer.cycle };
+            return {};
+        }
+        case 'wait-for-connector':
+            // Floor placeholder (no connector named) = `serviceType` only; naming the
+            // connector/operation emits the `context` subscription.
+            return waitConnectorBag(task.waitConnector, { alwaysContext: false }, resolver, `${stageId}-${taskId}`);
+    }
+}
+/**
+ * The `wait-for-connector` subscription bag (`data` on the task, `uipath` on the
+ * rule). Verified against a real `uip maestro case` caseplan: a placeholder
+ * carries `serviceType: "Intsvc.WaitForEvent"`; naming the connector adds a
+ * two-entry `context` (connectorKey + operation, defaulting to `"placeholder"`)
+ * and empty `inputs`/`outputs`/`bindings`. A *rule* always carries the context —
+ * `validate` rejects a bare `uipath` ("connector activity missing").
+ */
+function waitConnectorBag(spec, opts, resolver, elementId) {
+    if (isResolvedSubscription(spec))
+        return resolvedSubscriptionBag('event', spec, resolver, elementId);
+    const bag = { serviceType: CASE_FORMAT_PROFILE.waitConnectorServiceType };
+    const named = spec?.connectorKey !== undefined || spec?.operation !== undefined;
+    if (opts.alwaysContext || named) {
+        bag.context = [
+            { name: 'connectorKey', type: 'string', value: spec?.connectorKey ?? 'placeholder' },
+            { name: 'operation', type: 'string', value: spec?.operation ?? 'placeholder' },
+        ];
+        bag.inputs = [];
+        bag.outputs = [];
+        bag.bindings = [];
+    }
+    return bag;
+}
+function isResolvedSubscription(spec) {
+    return !!spec && 'connector' in spec && 'event' in spec;
+}
+/** Resolve a Case event/wait subscription into the designer/runtime bag pinned
+ * by the archived v1 artifacts. Placeholder bags never enter this path. */
+function resolvedSubscriptionBag(kind, spec, resolver, elementId) {
+    if (!resolver.library)
+        throw new Error(`${kind === 'trigger' ? 'event trigger' : 'wait-for-connector'} needs the connector library — `
+            + `pass { library } to serialize or use uip maestro case compile --library.`);
+    const rc = resolver.library.resolveEvent(kind, spec.connector, spec.event, spec.version);
+    const op = rc.entry.operation ?? {};
+    const context = [io('connectorKey', 'string', { value: rc.connectorKey })];
+    const connection = bindingRef(resolver, spec.connection, 'Connection', 'ConnectionId', `${rc.connectorKey} connection`);
+    if (connection) {
+        context.push(io('connection', 'string', { value: `=bindings.${connection.id}` }));
+        context.push(io('resourceKey', 'string', { value: connection.resourceKey }));
+    }
+    const folder = bindingRef(resolver, spec.folder, 'Connection', 'folderKey', 'FolderKey');
+    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) }));
+    return {
+        serviceType: kind === 'trigger' ? CASE_FORMAT_PROFILE.eventServiceType : CASE_FORMAT_PROFILE.waitConnectorServiceType,
+        context,
+        inputs: [eventInput(spec.where ?? {}, elementId)],
+        outputs: connectorOutputs(rc, elementId, resolver),
+        bindings: [],
+    };
+}
+function eventInput(where, elementId) {
+    // Case compile does not read resolutions.json (Flow does); a token here
+    // would be emitted raw where the connector expects an id.
+    for (const [field, value] of Object.entries(where))
+        refuseLookupToken(value, 'case', field);
+    return Object.keys(where).length
+        ? { 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) {
+    const instanceParameters = {
+        connectorKey: rc.connectorKey,
+        objectName: op.objectName ?? rc.nodeType.split('.').pop(),
+        activityType: op.activityType,
+        version: rc.version,
+        eventOperation: op.eventOperation,
+        eventMode: op.eventMode,
+        supportsStreaming: op.supportsStreaming ?? false,
+    };
+    const filter = filters.length ? {
+        groupOperator: 0,
+        index: 0,
+        filters: filters.map((entry, index) => {
+            // Same authored shape as a flow's event filter, same designer grammar (see
+            // `event-filters.ts`); a malformed leaf is refused rather than dropped.
+            const { read } = readEventFilter(entry);
+            if (!read)
+                throw new Error(`event filter ${index} must carry a field and exactly one operator — got ${JSON.stringify(entry)}.`);
+            const problem = eventFilterProblem(read);
+            if (problem)
+                throw new Error(`event filter ${index} on \`${read.field}\`: ${problem}`);
+            return {
+                ...eventFilterTreeLeaf(read),
+                uiId: stableUuid(`${elementId}:${read.field}:${String(read.value)}:${index}`),
+            };
+        }).map((leaf) => ({
+            id: leaf.id,
+            operator: leaf.operator,
+            value: leaf.value,
+            uiId: leaf.uiId,
+        })),
+        groups: [],
+        uuId: stableUuid(`${elementId}:filters`),
+    } : null;
+    const configuration = {
+        essentialConfiguration: {
+            connectorVersion: null,
+            executionType: null,
+            customFieldsRequestDetails: null,
+            instanceParameters,
+            objectName: instanceParameters.objectName,
+            packageVersion: rc.version,
+            httpMethod: null,
+            path: null,
+            filter,
+        },
+    };
+    return {
+        activityPropertyConfiguration: {
+            objectName: instanceParameters.objectName,
+            eventType: op.eventOperation,
+            eventMode: op.eventMode,
+            configuration: `=jsonString:${JSON.stringify(configuration)}`,
+            uiPathActivityTypeId: rc.activityTypeId ?? '',
+            errorState: { issues: [] },
+        },
+        activityMetadata: {
+            activity: {
+                displayName: rc.entry.display?.label ?? instanceParameters.objectName,
+                description: rc.entry.display?.description ?? '',
+                category: rc.connectorName,
+                configuration: JSON.stringify(instanceParameters),
+                uiPathActivityTypeId: rc.activityTypeId ?? '',
+                isEnabled: true,
+            },
+        },
+        telemetryData: {
+            connectorKey: rc.connectorKey,
+            connectorName: rc.connectorName,
+            objectName: instanceParameters.objectName,
+            objectDisplayName: op.objectDisplayName ?? rc.entry.display?.operationLabel ?? '',
+        },
+    };
+}
+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
+// matrix). Each row is `Variable`-shaped; `elementId` is "<stageId>-<taskId>". An
+// input binds a resource param to a literal/`=vars.X`/`=js:` value; an output
+// extracts a result field (`source`) into a case variable (`var`), registering a
+// root `inputOutputs` companion (`id === var`) so `=vars.<var>` resolves.
+/**
+ * One action-task form field → a schema `InputOutput` row. Unlike reference-mode
+ * io-binding, most form fields carry only a name + type plus optional Action
+ * Center metadata. A designer output with `value` names its readable case
+ * variable and therefore also carries the standard output identity fields.
+ */
+function emitActionField(f, outputElementId, resolver) {
+    const row = { name: f.name, type: f.type ?? 'string' };
+    if (f.subType !== undefined)
+        row.subType = f.subType;
+    if (f.displayName !== undefined)
+        row.displayName = f.displayName;
+    if (f.value !== undefined)
+        row.value = f.value;
+    if (outputElementId !== undefined && f.value !== undefined) {
+        row.id = f.value;
+        row.var = f.value;
+        row.source = `=${f.name}`;
+        row.target = `=${f.value}`;
+        row.elementId = outputElementId;
+        if (resolver && !resolver.varCompanions.has(f.value)) {
+            resolver.varCompanions.set(f.value, {
+                id: f.value,
+                name: f.value,
+                type: f.type ?? 'string',
+                elementId: 'root',
+                custom: true,
+            });
+        }
+    }
+    if (f.required !== undefined)
+        row.required = f.required;
+    if (f.options !== undefined)
+        row.options = f.options.map((option) => ({ value: option.value, label: option.label }));
+    return row;
+}
+/** One `data.inputs[]` row: a resource input param set to `value`. */
+function emitTaskInput(inp, elementId, ids, seed) {
+    const slot = ids.make('v', 8, seed);
+    return { name: inp.name, type: inp.type, id: slot, var: slot, elementId, value: inp.value };
+}
+/** One `data.outputs[]` row (the extract shape): `source` field → the `var` case variable. */
+function emitTaskOutput(o, elementId, ids, seed, resolver) {
+    const slot = ids.make('o', 8, seed);
+    const field = o.source.replace(/^=/, '').split('.').pop() || o.source;
+    // Register the readable companion once (declared vars take precedence in the merge).
+    if (!resolver.varCompanions.has(o.var))
+        resolver.varCompanions.set(o.var, { id: o.var, name: o.var, type: o.type, elementId: 'root', custom: true });
+    return {
+        name: field,
+        type: o.type,
+        id: slot,
+        var: o.var,
+        originalVar: slot,
+        value: o.var,
+        source: o.source,
+        target: `=${slot}`,
+        elementId,
+    };
+}
+// ─── Connector task (execute-connector-activity) ──────────────────────────────
+/**
+ * Build the `execute-connector-activity` `data` payload for an IS connector task,
+ * from the same `ResolvedConnector` the Flow node uses (verified against a real
+ * `uip maestro case` caseplan — see docs/CONNECTORS_DESIGN.md §C). The connector
+ * wiring lives in `context[]` (connectorKey/objectName/method/path + the
+ * essentialConfiguration blob); `inputs[]` splits into pathParameters/
+ * queryParameters/body by the op's declared parameters; `outputs[]` comes from
+ * the op's output schema. Connection/folder resolve through `bindings` and are
+ * referenced as `=bindings.<id>`, with the binding entry collected at case root.
+ */
+function connectorTaskData(spec, resolver, elementId) {
+    if (!resolver.library)
+        throw new Error(`connector task needs the connector library — pass { library } to serialize or use uip maestro case compile --library.`);
+    const rc = resolver.library.resolve(spec.key, spec.action, spec.version, spec.object);
+    const op = rc.entry.operation ?? {};
+    const params = Array.isArray(op.parameters) ? op.parameters : [];
+    const context = [
+        io('connectorKey', 'string', { value: rc.connectorKey }),
+    ];
+    // connection + folder → root bindings, referenced by id.
+    const connRef = bindingRef(resolver, spec.connection, 'Connection', 'ConnectionId', `${rc.connectorKey} connection`);
+    if (connRef) {
+        context.push(io('connection', 'string', { value: `=bindings.${connRef.id}` }));
+        context.push(io('resourceKey', 'string', { value: connRef.resourceKey }));
+    }
+    const folderRef = bindingRef(resolver, spec.folder, 'Connection', 'folderKey', 'FolderKey');
+    if (folderRef)
+        context.push(io('folderKey', 'string', { value: `=bindings.${folderRef.id}` }));
+    context.push(io('objectName', 'string', { value: op.objectName ?? spec.action }), io('method', 'string', { value: transportHttpMethod(rc.httpMethod) }), io('path', 'string', { value: rc.endpoint }), io('metadata', 'json', { body: connectorMetadata(rc, op) }));
+    // inputs: split declared parameters into path/query slots; the rest is the body.
+    //
+    // Guard BEFORE the split. These values are emitted verbatim, so an unresolved
+    // lookup ships as `{"__lookup": …}` where the connector wants an id — verified
+    // by probe before this existed. Only Flow reads resolutions.json.
+    for (const [name, value] of Object.entries(spec.inputs ?? {})) {
+        refuseLookupToken(value, 'case', name);
+    }
+    const pathParameters = {};
+    const queryParameters = {};
+    const body = { ...spec.inputs };
+    for (const p of params) {
+        const name = String(p.name ?? '');
+        if (!(name in body))
+            continue;
+        const camel = toCamel(name);
+        if (p.type === 'path') {
+            pathParameters[camel] = body[name];
+            delete body[name];
+        }
+        else if (p.type === 'query') {
+            queryParameters[camel] = body[name];
+            delete body[name];
+        }
+    }
+    const inputs = [
+        ioSlot('pathParameters', pathParameters, `${elementId}`),
+        ioSlot('queryParameters', queryParameters, `${elementId}`),
+        ioSlot('body', body, `${elementId}`),
+    ];
+    const outputs = connectorOutputs(rc, elementId, resolver);
+    return { serviceType: CASE_FORMAT_PROFILE.connectorActivityServiceType, context, inputs, outputs, bindings: [] };
+}
+function externalTaskData(kind, spec, resolver) {
+    if (!resolver.library)
+        throw new Error(`${kind} task needs the connector library — pass { library } to serialize or use uip maestro case compile --library.`);
+    const rc = resolver.library.resolve(spec.connector.key, spec.connector.action, spec.connector.version, spec.connector.object);
+    const op = rc.entry.operation ?? {};
+    const expectedSubType = kind === 'external-agent' ? 'AgentExecution' : 'ProcessExecution';
+    if (op.subType !== expectedSubType)
+        throw new Error(`${kind} task requires a ${expectedSubType} descriptor; resolved ${String(op.subType ?? 'no subtype')}.`);
+    if (!rc.activityTypeId)
+        throw new Error(`${kind} task descriptor ${rc.nodeType}@${rc.version} has no uiPathActivityTypeId.`);
+    if (spec.mode !== 'sync' && spec.mode !== 'async')
+        throw new Error(`${kind} task mode must be "sync" or "async".`);
+    const connection = bindingRef(resolver, spec.connector.connection, 'Connection', 'ConnectionId', `${rc.connectorKey} connection`);
+    const folder = bindingRef(resolver, spec.connector.folder, 'Connection', 'folderKey', 'FolderKey');
+    if (!connection || !folder)
+        throw new Error(`${kind} task requires non-empty connection and folder binding names.`);
+    const serviceType = kind === 'external-agent'
+        ? (spec.mode === 'sync'
+            ? CASE_FORMAT_PROFILE.externalAgentSyncServiceType
+            : CASE_FORMAT_PROFILE.externalAgentAsyncServiceType)
+        : (spec.mode === 'sync'
+            ? CASE_FORMAT_PROFILE.externalWorkflowSyncServiceType
+            : CASE_FORMAT_PROFILE.externalWorkflowAsyncServiceType);
+    const fields = new Map(rc.fields.map((field) => [field.name, field]));
+    const unknown = Object.keys(spec.connector.inputs).find((name) => !fields.has(name));
+    if (unknown)
+        throw new Error(`${kind} task has unknown input "${unknown}" for ${rc.nodeType}@${rc.version}.`);
+    const missing = rc.fields.find((field) => field.required && !(field.name in spec.connector.inputs));
+    if (missing)
+        throw new Error(`${kind} task is missing required input "${missing.name}".`);
+    const responseVar = connectorOutputVar(resolver, 'response');
+    return {
+        serviceType,
+        context: [
+            io('activity', 'string', { value: rc.activityTypeId }),
+            io('connectorKey', 'string', { value: rc.connectorKey }),
+            io('connection', 'string', { value: `=bindings.${connection.id}` }),
+            io('folderKey', 'string', { value: `=bindings.${folder.id}` }),
+            io('method', 'string', { value: transportHttpMethod(rc.httpMethod) }),
+            io('path', 'string', { value: rc.endpoint }),
+        ],
+        inputs: Object.entries(spec.connector.inputs).map(([name, value]) => ({
+            id: name,
+            name,
+            type: jsonType(fields.get(name)?.type),
+            value,
+            target: name,
+        })),
+        outputs: [{
+                id: responseVar,
+                name: 'response',
+                type: 'json',
+                source: '.',
+                var: responseVar,
+            }],
+        bindings: [],
+    };
+}
+/** A context/output name/value entry (the caseplan `InputOutput` shape). */
+function io(name, type, extra) {
+    return { name, type, ...extra };
+}
+/** An `inputs[]` json slot (pathParameters/queryParameters/body). */
+function ioSlot(name, bodyObj, elementId) {
+    const v = `v${name}`;
+    return { name, type: 'json', target: name, body: bodyObj, var: v, id: v, elementId };
+}
+/** Resolve a symbolic connection/folder to a root binding entry (collected once),
+ * returning its id + resourceKey for the `=bindings.<id>` reference. */
+function bindingRef(resolver, name, resource, propertyAttribute, displayName) {
+    if (!name)
+        return undefined;
+    const entry = resolver.bindings?.entry(name);
+    const id = entry?.id ?? name;
+    const resourceKey = entry?.resourceKey ?? entry?.default ?? name;
+    if (!resolver.bindingSink.has(id)) {
+        resolver.bindingSink.set(id, {
+            id,
+            name: entry?.name ?? displayName,
+            type: 'string',
+            resource,
+            resourceKey,
+            default: entry?.default ?? resourceKey,
+            propertyAttribute,
+        });
+    }
+    return { id, resourceKey };
+}
+/** The connector `metadata` json blob: the FUNCTIONAL essentialConfiguration +
+ * activityTypeId. Designer cosmetics (packageId/activityColor/…) are omitted —
+ * the caseplan schema-validates without them (see design §C). */
+function connectorMetadata(rc, op) {
+    const instanceParameters = {
+        connectorKey: rc.connectorKey,
+        objectName: op.objectName ?? rc.nodeType.split('.').pop(),
+        httpMethod: rc.httpMethod,
+        activityType: op.activityType ?? 'Curated',
+        version: rc.version,
+        supportsStreaming: op.supportsStreaming ?? false,
+        subType: op.subType ?? 'standard',
+    };
+    const configuration = {
+        essentialConfiguration: {
+            instanceParameters,
+            objectName: instanceParameters.objectName,
+            httpMethod: transportHttpMethod(rc.httpMethod),
+            path: rc.endpoint,
+            packageVersion: rc.version,
+        },
+    };
+    return {
+        activityPropertyConfiguration: {
+            configuration: `=jsonString:${JSON.stringify(configuration)}`,
+            uiPathActivityTypeId: rc.activityTypeId ?? '',
+            errorState: { issues: [] },
+        },
+        activityMetadata: {
+            activity: {
+                displayName: rc.entry.display?.label ?? instanceParameters.objectName,
+                description: rc.entry.display?.description ?? '',
+                category: rc.connectorName,
+                configuration: JSON.stringify(instanceParameters),
+                uiPathActivityTypeId: rc.activityTypeId ?? '',
+                isEnabled: true,
+            },
+        },
+        telemetryData: {
+            connectorKey: rc.connectorKey,
+            connectorName: rc.connectorName,
+            objectName: instanceParameters.objectName,
+            objectDisplayName: op.objectDisplayName ?? rc.entry.display?.operationLabel ?? '',
+        },
+    };
+}
+/** The `outputs[]`: a `response` json-schema from the op's output schema, plus a
+ * standard `Error` schema. */
+function connectorOutputVar(resolver, base) {
+    const occurrence = (resolver.connectorOutputCounts.get(base) ?? 0) + 1;
+    resolver.connectorOutputCounts.set(base, occurrence);
+    return occurrence === 1 ? base : `${base}${occurrence}`;
+}
+function connectorOutputs(rc, elementId, resolver) {
+    const responseSchema = rc.entry.outputSchema
+        ? schemaFromFields(rc.entry.outputSchema.fields ?? [])
+        : { type: 'object', properties: {} };
+    const responseVar = connectorOutputVar(resolver, 'response');
+    const errorVar = connectorOutputVar(resolver, 'Error');
+    return [
+        {
+            name: 'response', displayName: 'Response', type: 'jsonSchema', source: '=response',
+            body: { $schema: 'http://json-schema.org/draft-07/schema#', ...responseSchema },
+            var: responseVar, id: responseVar, value: responseVar, target: `=${responseVar}`, elementId,
+        },
+        {
+            name: 'Error', displayName: 'Error', type: 'jsonSchema', source: '=Error',
+            body: {
+                type: 'object',
+                properties: {
+                    code: { type: 'string' }, message: { type: 'string' }, detail: { type: 'string' },
+                    category: { type: 'string' }, status: { type: 'number' }, element: { type: 'string' },
+                },
+            },
+            var: errorVar, id: errorVar, value: errorVar, target: `=${errorVar}`, elementId,
+        },
+    ];
+}
+/** A minimal JSON-schema `{type:object, properties}` from library output fields. */
+function schemaFromFields(fields) {
+    const properties = {};
+    for (const f of fields) {
+        const name = f?.name;
+        if (!name)
+            continue;
+        properties[name] = { title: f.displayName ?? name, type: jsonType(f.type) };
+    }
+    return { type: 'object', properties };
+}
+function jsonType(t) {
+    switch (String(t ?? '').toLowerCase()) {
+        case 'number':
+        case 'integer':
+        case 'float': return 'number';
+        case 'boolean':
+        case 'bool': return 'boolean';
+        case 'object': return 'object';
+        case 'array': return 'array';
+        default: return 'string';
+    }
+}
+/** snake_case → camelCase (the caseplan camelCases declared param names). */
+function toCamel(s) {
+    return s.replace(/_([a-z0-9])/gi, (_m, c) => String(c).toUpperCase());
+}
+// ─── Conditions & rules ───────────────────────────────────────────────────────
+function emitRules(rules, seed, ownerId, ids, resolver) {
+    return rules.map((group, gi) => group.map((r, ri) => emitRule(r, `${seed}:${gi}:${ri}`, ownerId, ids, resolver)));
+}
+function emitRule(r, seed, ownerId, ids, resolver) {
+    const ruleId = ids.ruleId(seed);
+    const out = { rule: r.rule, id: ruleId };
+    if (r.rule === 'selected-stage-completed' || r.rule === 'selected-stage-exited') {
+        const sid = r.stage && resolver.stageIdByLabel.get(r.stage);
+        if (!sid)
+            throw new Error(`rule "${r.rule}" references unknown stage "${r.stage}".`);
+        out[CASE_FORMAT_PROFILE.selectedStageField] = CASE_FORMAT_PROFILE.selectedStageCardinality === 'singular' ? sid : [sid];
+    }
+    if (r.rule === 'selected-tasks-completed') {
+        const names = r.tasks ?? [];
+        out.selectedTasksIds = names.map((n) => {
+            const tid = resolver.taskIdByKey.get(n);
+            if (!tid)
+                throw new Error(`rule "selected-tasks-completed" references unknown task "${n}".`);
+            return tid;
+        });
+    }
+    if (r.rule === 'wait-for-connector') {
+        // A rule always carries the subscription under `uipath` (placeholder-safe).
+        out[CASE_FORMAT_PROFILE.waitConnectorRuleBagField] = waitConnectorBag(r.connector, { alwaysContext: true }, resolver, `${ownerId}-${ruleId}`);
+    }
+    if (r.rule === 'sla-status-change') {
+        // Resolve the SLA (and, for at-risk, the escalation) by displayName → the
+        // preallocated id. `slaId` alone = a breach rule; adding `escalationId` = at-risk.
+        const slaId = r.sla && resolver.slaIdByName.get(r.sla);
+        if (!slaId)
+            throw new Error(`rule "sla-status-change" references unknown SLA "${r.sla}" — declare it with .sla({ displayName: "${r.sla}", … }).`);
+        out.slaId = slaId;
+        if (r.escalation) {
+            const escId = resolver.escalationIdByName.get(r.escalation);
+            if (!escId)
+                throw new Error(`rule "sla-status-change" references unknown escalation "${r.escalation}".`);
+            out.escalationId = escId;
+        }
+    }
+    if (r.expression)
+        out.conditionExpression = r.expression;
+    return out;
+}
+function emitEntry(c, seed, ownerId, label, ids, resolver) {
+    const out = {
+        id: ids.conditionId(seed),
+        displayName: resolver.conditionName(c.displayName, `${label} entry`),
+        rules: emitRules(c.rules, seed, ownerId, ids, resolver),
+    };
+    if (c.isInterrupting !== undefined)
+        out.isInterrupting = c.isInterrupting;
+    return out;
+}
+function emitExit(c, seed, ownerId, label, ids, resolver) {
+    const out = {
+        id: ids.conditionId(seed),
+        displayName: resolver.conditionName(c.displayName, `${label} ${c.marksStageComplete ? 'complete' : 'exit'}`),
+        rules: emitRules(c.rules, seed, ownerId, ids, resolver),
+    };
+    if (c.marksStageComplete !== undefined)
+        out.marksStageComplete = c.marksStageComplete;
+    if (c.type)
+        out.type = c.type;
+    if (c.exitToStage) {
+        const sid = resolver.stageIdByLabel.get(c.exitToStage);
+        if (!sid)
+            throw new Error(`exit condition routes to unknown stage "${c.exitToStage}".`);
+        out.exitToStageId = sid;
+    }
+    return out;
+}
+function emitTaskEntry(c, seed, ownerId, label, ids, resolver) {
+    return {
+        id: ids.conditionId(seed),
+        displayName: resolver.conditionName(c.displayName, `${label} entry`),
+        rules: emitRules(c.rules, seed, ownerId, ids, resolver),
+    };
+}
+function emitCaseExit(c, i, ids, resolver) {
+    const seed = `case:exit:${i}`;
+    const out = {
+        id: ids.conditionId(seed),
+        displayName: resolver.conditionName(c.displayName, 'Case complete'),
+        rules: emitRules(c.rules, seed, 'root', ids, resolver),
+    };
+    if (c.marksCaseComplete !== undefined)
+        out.marksCaseComplete = c.marksCaseComplete;
+    return out;
+}
+/** One `slaRules[]` entry: the deadline + its escalations. `id` (+ `displayName`
+ * when named) is preallocated so a `sla-status-change` rule can reference it. */
+function emitSla(sla, index, count, ids, resolver) {
+    const displayName = sla.displayName ?? (index === count - 1 ? 'Default SLA' : `Conditional SLA ${count - index - 1}`);
+    const out = {
+        id: resolver.slaId.get(sla),
+        ...(sla.displayName || CASE_FORMAT_PROFILE.requireSlaDisplayNames ? { displayName } : {}),
+        expression: sla.expression,
+        count: sla.count,
+        unit: sla.unit,
+    };
+    if (sla.escalations.length) {
+        out.escalationRule = sla.escalations.map((e, escalationIndex) => emitEscalation(e, escalationIndex, displayName, resolver));
+    }
+    return out;
+}
+/** One escalation: a trigger (at-risk % or breach) and a notification action. */
+function emitEscalation(e, index, slaDisplayName, resolver) {
+    const triggerInfo = { type: e.trigger };
+    if (e.trigger === 'at-risk')
+        triggerInfo.atRiskPercentage = e.atRiskPercentage ?? 100;
+    return {
+        id: resolver.escalationId.get(e),
+        ...(e.displayName || CASE_FORMAT_PROFILE.requireSlaDisplayNames
+            ? { displayName: e.displayName ?? `Escalation rule ${index + 1} - ${slaDisplayName}` }
+            : {}),
+        triggerInfo,
+        action: {
+            type: 'notification',
+            recipients: e.notify.map((r) => ({ scope: r.scope, target: r.target, value: r.value ?? r.target })),
+        },
+    };
+}