@uipath/maestro-builder-sdk 5.2.0

package/dist/case/decompile.js

@@ -0,0 +1,1170 @@
+import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
+import { preserveSchemaVersion } from '../schema-version.js';
+const TASK_KIND_METHOD = {
+    process: 'process',
+    agent: 'agent',
+    rpa: 'rpa',
+    'api-workflow': 'apiWorkflow',
+    'case-management': 'caseManagement',
+    'flow-process': 'flowProcess',
+};
+function str(value) {
+    return JSON.stringify(value).replace(/[\u2028\u2029]/g, (char) => `\\u${char.charCodeAt(0).toString(16)}`);
+}
+function boolLit(value) {
+    return value ? 'true' : 'false';
+}
+function key(value) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value) ? value : str(value);
+}
+function literal(value) {
+    const rendered = JSON.stringify(value);
+    if (rendered === undefined)
+        throw new Error('cannot decompile a non-JSON value.');
+    return rendered.replace(/[\u2028\u2029]/g, (char) => `\\u${char.charCodeAt(0).toString(16)}`);
+}
+function opts(entries) {
+    const parts = entries.filter((entry) => entry[1] !== undefined)
+        .map(([name, value]) => `${key(name)}: ${value}`);
+    return parts.length ? `{ ${parts.join(', ')} }` : '';
+}
+class Emit {
+    lines = [];
+    line(depth, text) {
+        this.lines.push('  '.repeat(depth) + text);
+    }
+    toString() {
+        return this.lines.join('\n');
+    }
+}
+function nodeType(node) {
+    return String(node.type ?? '');
+}
+function isStage(node) {
+    return nodeType(node).endsWith('Stage') && !isTrigger(node);
+}
+function isTrigger(node) {
+    return nodeType(node) === 'case-management:Trigger' || nodeType(node) === 'uipath.case.trigger';
+}
+function addSlaRefs(slas, refs) {
+    for (const sla of slas ?? []) {
+        if (sla.id && sla.displayName)
+            refs.slaNameById.set(sla.id, sla.displayName);
+        for (const escalation of sla.escalationRule ?? []) {
+            if (escalation.id && escalation.displayName)
+                refs.escalationNameById.set(escalation.id, escalation.displayName);
+        }
+    }
+}
+function buildRefs(plan, library, diagnostics) {
+    const refs = {
+        stageLabelById: new Map(),
+        taskNameById: new Map(),
+        slaNameById: new Map(),
+        escalationNameById: new Map(),
+        bindingById: new Map(),
+        library,
+        diagnostics,
+    };
+    for (const binding of plan.bindings ?? [])
+        if (binding.id)
+            refs.bindingById.set(binding.id, binding);
+    addSlaRefs(plan.metadata?.slaRules, refs);
+    for (const node of plan.nodes ?? []) {
+        if (!isStage(node))
+            continue;
+        if (node.id && node.data?.label)
+            refs.stageLabelById.set(node.id, node.data.label);
+        addSlaRefs(node.data?.slaRules, refs);
+        for (const lane of node.data?.tasks ?? [])
+            for (const task of lane)
+                if (task.id && task.displayName)
+                    refs.taskNameById.set(task.id, task.displayName);
+    }
+    return refs;
+}
+function diagnose(refs, diagnostic) {
+    if (!refs.diagnostics)
+        throw new Error(diagnostic.message);
+    refs.diagnostics.push(diagnostic);
+}
+function contextMap(bag) {
+    return new Map((bag?.context ?? []).map((row) => [String(row.name ?? ''), row]));
+}
+function waitConnectorSpec(bag, owner, refs) {
+    if (!bag || bag.serviceType !== CASE_FORMAT_PROFILE.waitConnectorServiceType)
+        throw new Error(`${owner} has an unsupported wait-for-connector subscription.`);
+    const allowed = new Set(['serviceType', 'context', 'inputs', 'outputs', 'bindings']);
+    if (Object.keys(bag).some((name) => !allowed.has(name)))
+        throw new Error(`${owner} has an unsupported wait-for-connector subscription field.`);
+    if (bag.context === undefined) {
+        const hasResolvedFields = ['inputs', 'outputs', 'bindings'].some((name) => {
+            const value = bag[name];
+            return Array.isArray(value) && value.length > 0;
+        });
+        if (!hasResolvedFields)
+            return undefined;
+        return resolvedSubscriptionSource(bag, owner, 'event', refs);
+    }
+    const context = contextMap(bag);
+    const isPlaceholder = bag.context.length === 2 && context.size === 2
+        && context.has('connectorKey') && context.has('operation')
+        && ['inputs', 'outputs', 'bindings'].every((name) => {
+            const value = bag[name];
+            return value === undefined || (Array.isArray(value) && value.length === 0);
+        });
+    const connectorKey = context.get('connectorKey')?.value;
+    const operation = context.get('operation')?.value;
+    if (typeof connectorKey !== 'string' || typeof operation !== 'string')
+        throw new Error(`${owner} has an incomplete wait-for-connector subscription context.`);
+    if (isPlaceholder) {
+        if (connectorKey === 'placeholder' && operation === 'placeholder')
+            return '{}';
+        return opts([
+            ['connectorKey', str(connectorKey)],
+            ['operation', str(operation)],
+        ]);
+    }
+    return resolvedSubscriptionSource(bag, owner, 'event', refs);
+}
+function encodedSubscriptionConfig(context, owner) {
+    const encoded = context.get('metadata')?.body?.activityPropertyConfiguration?.configuration;
+    if (typeof encoded !== 'string' || !encoded.startsWith('=jsonString:'))
+        throw new Error(`${owner} has missing or malformed subscription metadata configuration.`);
+    try {
+        return JSON.parse(encoded.slice('=jsonString:'.length))?.essentialConfiguration ?? {};
+    }
+    catch {
+        throw new Error(`${owner} has malformed subscription metadata configuration JSON.`);
+    }
+}
+function subscriptionWhere(bag, owner) {
+    const inputs = bag.inputs;
+    if (!Array.isArray(inputs) || inputs.length !== 1)
+        throw new Error(`${owner} must carry exactly one resolved subscription input.`);
+    const row = inputs[0];
+    if (row?.name !== 'body')
+        throw new Error(`${owner} has an unsupported subscription input.`);
+    if (row.value === '' && row.body === undefined)
+        return undefined;
+    const queryParams = row.body?.queryParams;
+    if (!queryParams || typeof queryParams !== 'object' || Array.isArray(queryParams))
+        throw new Error(`${owner} has an unsupported subscription body.`);
+    const entries = Object.entries(queryParams);
+    if (entries.some(([, value]) => typeof value !== 'string'))
+        throw new Error(`${owner} has a non-string subscription parameter.`);
+    return Object.fromEntries(entries);
+}
+function subscriptionFilters(config, owner) {
+    const tree = config?.filter;
+    if (tree === null || tree === undefined)
+        return undefined;
+    if (!Array.isArray(tree.filters) || (tree.groups?.length ?? 0) !== 0)
+        throw new Error(`${owner} has an unsupported nested subscription filter.`);
+    const filters = tree.filters.map((entry) => {
+        if (entry?.operator !== 'Contains' || typeof entry.id !== 'string' || typeof entry.value?.value !== 'string')
+            throw new Error(`${owner} has an unsupported subscription filter operator.`);
+        return { field: entry.id, contains: entry.value.value };
+    });
+    return filters.length ? filters : undefined;
+}
+function resolvedSubscriptionSource(bag, owner, kind, refs) {
+    if (!refs.library)
+        throw new Error(`${owner} needs the connector library; pass DecompileOptions.library or --library.`);
+    const context = contextMap(bag);
+    const connectorKey = context.get('connectorKey')?.value;
+    const operation = context.get('operation')?.value;
+    const objectName = context.get('objectName')?.value;
+    if ([connectorKey, operation, objectName].some((value) => typeof value !== 'string'))
+        throw new Error(`${owner} has an incomplete resolved subscription context.`);
+    const connection = bindingName(context.get('connection')?.value, refs);
+    const folder = bindingName(context.get('folderKey')?.value, refs);
+    if (context.has('connection') && connection === undefined)
+        throw new Error(`${owner} connection must reference a root binding.`);
+    if (context.has('folderKey') && folder === undefined)
+        throw new Error(`${owner} folderKey must reference a root binding.`);
+    const config = encodedSubscriptionConfig(context, owner);
+    const identity = refs.library.identifyEvent(kind, {
+        connectorKey: String(connectorKey),
+        objectName: String(objectName),
+        eventOperation: String(operation),
+        eventMode: context.get('metadata')?.body?.activityPropertyConfiguration?.eventMode,
+        version: config.packageVersion,
+    });
+    const where = subscriptionWhere(bag, owner);
+    const filters = subscriptionFilters(config, owner);
+    return opts([
+        ['connector', str(identity.key)],
+        ['event', str(identity.event)],
+        ['where', where !== undefined ? literal(where) : undefined],
+        ['filters', filters !== undefined ? literal(filters) : undefined],
+        ['connection', connection !== undefined ? str(connection) : undefined],
+        ['folder', folder !== undefined ? str(folder) : undefined],
+        ['version', identity.version !== '1.0.0' ? str(identity.version) : undefined],
+    ]);
+}
+function emitRule(rule, refs) {
+    const entries = [];
+    const stageIds = rule.selectedStageIds ?? (rule.selectedStageId !== undefined ? [rule.selectedStageId] : undefined);
+    if (stageIds !== undefined) {
+        if (stageIds.length !== 1)
+            throw new Error(`rule "${rule.rule}" selects ${stageIds.length} stages; multi-stage selection is not authorable.`);
+        let label = refs.stageLabelById.get(stageIds[0]);
+        if (label === undefined) {
+            const message = `rule "${rule.rule}" references unknown stage id "${stageIds[0]}".`;
+            diagnose(refs, {
+                code: 'UNKNOWN_STAGE_REFERENCE',
+                message,
+                location: `rule:${rule.id ?? rule.rule}`,
+            });
+            label = `__UNRESOLVED_STAGE_ID__:${stageIds[0]}`;
+        }
+        entries.push(['stage', str(label)]);
+    }
+    if (rule.selectedTasksIds !== undefined) {
+        const names = rule.selectedTasksIds.map((id) => {
+            const name = refs.taskNameById.get(id);
+            if (name !== undefined)
+                return str(name);
+            const message = `rule "${rule.rule}" references unknown task id "${id}".`;
+            diagnose(refs, {
+                code: 'UNKNOWN_TASK_REFERENCE',
+                message,
+                location: `rule:${rule.id ?? rule.rule}`,
+            });
+            return str(`__UNRESOLVED_TASK_ID__:${id}`);
+        });
+        entries.push(['tasks', `[${names.join(', ')}]`]);
+    }
+    if (rule.rule === 'wait-for-connector') {
+        const connector = waitConnectorSpec(rule.uipath, `rule "${rule.rule}"`, refs);
+        if (connector && connector !== '{}')
+            entries.push(['connector', connector]);
+    }
+    if (rule.rule === 'sla-status-change') {
+        const sla = rule.slaId && refs.slaNameById.get(rule.slaId);
+        if (!sla)
+            throw new Error(`sla-status-change rule references unnamed or unknown SLA id "${rule.slaId ?? ''}".`);
+        entries.push(['sla', str(sla)]);
+        if (rule.escalationId !== undefined) {
+            const escalation = refs.escalationNameById.get(rule.escalationId);
+            if (!escalation)
+                throw new Error(`sla-status-change rule references unnamed or unknown escalation id "${rule.escalationId}".`);
+            entries.push(['escalation', str(escalation)]);
+        }
+    }
+    if (rule.conditionExpression !== undefined)
+        entries.push(['expression', str(rule.conditionExpression)]);
+    const options = opts(entries);
+    return options ? `rule(${str(rule.rule)}, ${options})` : `rule(${str(rule.rule)})`;
+}
+function emitRuleArg(condition, refs) {
+    const groups = condition.rules ?? [];
+    const rendered = groups.map((group) => group.map((rule) => emitRule(rule, refs)));
+    if (rendered.length === 1)
+        return rendered[0].length === 1 ? rendered[0][0] : `[${rendered[0].join(', ')}]`;
+    return `[${rendered.map((group) => `[${group.join(', ')}]`).join(', ')}]`;
+}
+function emitEntryWhen(out, depth, condition, refs, stage) {
+    // Emit the name whenever the document carries one. This used to drop it when it
+    // equalled the serializer's old constant default ("Entry rule"), which was safe
+    // only while that default was a constant: now that an omitted name is DERIVED
+    // from the owner, dropping it would make decompile → compile rename the rule.
+    // Round-trip identity over the existing corpus beats a tidier generated source.
+    const displayName = condition.displayName ? str(condition.displayName) : undefined;
+    const options = opts([
+        ['displayName', displayName],
+        ['isInterrupting', stage && condition.isInterrupting !== undefined ? boolLit(condition.isInterrupting) : undefined],
+    ]);
+    const arg = emitRuleArg(condition, refs);
+    out.line(depth, options ? `.entryWhen(${arg}, ${options})` : `.entryWhen(${arg})`);
+}
+function emitExitWhen(out, depth, condition, refs, selectNextStage) {
+    // See emitEntryWhen: the name is preserved verbatim so the round trip is exact.
+    const displayName = condition.displayName ? str(condition.displayName) : undefined;
+    let exitToStage;
+    if (condition.exitToStageId !== undefined) {
+        let label = refs.stageLabelById.get(condition.exitToStageId);
+        if (label === undefined) {
+            const message = `exit condition routes to unknown stage id "${condition.exitToStageId}".`;
+            diagnose(refs, {
+                code: 'UNKNOWN_EXIT_TARGET',
+                message,
+                location: `condition:${condition.id ?? condition.displayName ?? 'exit'}`,
+            });
+            label = `__UNRESOLVED_STAGE_ID__:${condition.exitToStageId}`;
+        }
+        exitToStage = str(label);
+    }
+    const options = opts([
+        ['displayName', displayName],
+        ['marksStageComplete', condition.marksStageComplete !== undefined ? boolLit(condition.marksStageComplete) : undefined],
+        ['type', condition.type !== undefined ? str(condition.type) : undefined],
+        ['exitToStage', exitToStage],
+        ['selectNextStage', selectNextStage],
+    ]);
+    const arg = emitRuleArg(condition, refs);
+    out.line(depth, options ? `.exitWhen(${arg}, ${options})` : `.exitWhen(${arg})`);
+}
+function emitCompleteWhen(out, depth, condition, refs) {
+    // See emitEntryWhen: the name is preserved verbatim so the round trip is exact.
+    const displayName = condition.displayName
+        ? str(condition.displayName)
+        : undefined;
+    const options = opts([
+        ['displayName', displayName],
+        ['marksCaseComplete', condition.marksCaseComplete === false ? 'false' : undefined],
+    ]);
+    const arg = emitRuleArg(condition, refs);
+    out.line(depth, options ? `.completeWhen(${arg}, ${options})` : `.completeWhen(${arg})`);
+}
+function actionFields(rows) {
+    if (!rows?.length)
+        return undefined;
+    return `[${rows.map((row) => opts([
+        ['name', str(row.name ?? '')],
+        ['type', row.type && row.type !== 'string' ? str(row.type) : undefined],
+        ['subType', row.subType !== undefined ? str(row.subType) : undefined],
+        ['displayName', row.displayName !== undefined ? str(row.displayName) : undefined],
+        ['value', row.value !== undefined ? literal(row.value) : undefined],
+        ['required', row.required !== undefined ? literal(row.required) : undefined],
+        ['options', row.options !== undefined ? literal(row.options) : undefined],
+    ])).join(', ')}]`;
+}
+function bindingName(value, refs) {
+    if (typeof value !== 'string' || !value.startsWith('=bindings.'))
+        return undefined;
+    const id = value.slice('=bindings.'.length);
+    return refs.bindingById.get(id)?.id ?? id;
+}
+function bindingDefault(value, refs) {
+    if (typeof value !== 'string' || !value.startsWith('=bindings.'))
+        return value;
+    const id = value.slice('=bindings.'.length);
+    return refs.bindingById.get(id)?.default ?? value;
+}
+function selectNextStageByExit(plan, refs) {
+    const raw = plan.metadata?.waitForHumanSelectNextStageDFConnector;
+    if (raw === undefined)
+        return new Map();
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        throw new Error('waitForHumanSelectNextStageDFConnector must be a connector object.');
+    const connector = raw;
+    const allowed = new Set(['id', 'elementId', 'type', 'displayName', 'shouldRunOnlyOnce', 'data']);
+    const unknown = Object.keys(connector).find((name) => !allowed.has(name));
+    if (unknown)
+        throw new Error(`select-next-stage connector has unsupported field "${unknown}".`);
+    if (connector.id !== 'SelectNextStageConnector'
+        || connector.elementId !== 'root-SelectNextStageConnector'
+        || connector.type !== 'wait-for-connector'
+        || connector.displayName !== 'Select next stage'
+        || connector.shouldRunOnlyOnce !== false)
+        throw new Error('select-next-stage connector has unsupported identity or task settings.');
+    const data = connector.data;
+    if (!data || typeof data !== 'object' || Array.isArray(data) || data.serviceType !== CASE_FORMAT_PROFILE.waitConnectorServiceType)
+        throw new Error('select-next-stage connector has an unsupported data envelope.');
+    const dataAllowed = new Set(['serviceType', 'context', 'inputs', 'outputs', 'bindings']);
+    const unknownData = Object.keys(data).find((name) => !dataAllowed.has(name));
+    if (unknownData)
+        throw new Error(`select-next-stage connector data has unsupported field "${unknownData}".`);
+    for (const name of ['inputs', 'outputs', 'bindings'])
+        if (!Array.isArray(data[name]) || data[name].length !== 0)
+            throw new Error(`select-next-stage connector data.${name} must be an empty array.`);
+    if (!Array.isArray(data.context))
+        throw new Error('select-next-stage connector data.context must be an array.');
+    const context = contextMap({ context: data.context });
+    if (context.size !== data.context.length)
+        throw new Error('select-next-stage connector context names must be unique.');
+    const contextAllowed = new Set(['connectorKey', 'connection', 'resourceKey', 'folderKey', 'objectName', 'operation']);
+    const unknownContext = [...context.keys()].find((name) => !contextAllowed.has(name));
+    if (unknownContext)
+        throw new Error(`select-next-stage connector has unsupported context "${unknownContext}".`);
+    const objectName = context.get('objectName')?.value;
+    if (typeof objectName !== 'string' || !objectName.trim())
+        throw new Error('select-next-stage connector requires a non-empty objectName context value.');
+    const connectorKey = context.get('connectorKey')?.value;
+    const operation = context.get('operation')?.value;
+    const connection = bindingName(context.get('connection')?.value, refs);
+    const folder = bindingName(context.get('folderKey')?.value, refs);
+    const hasConnectorFields = connectorKey !== undefined || operation !== undefined
+        || context.has('connection') || context.has('resourceKey') || context.has('folderKey');
+    let connectorSource;
+    if (hasConnectorFields) {
+        if (typeof connectorKey !== 'string' || typeof operation !== 'string')
+            throw new Error('select-next-stage full connector requires string connectorKey and operation context values.');
+        if (context.has('connection') !== context.has('resourceKey'))
+            throw new Error('select-next-stage connector connection and resourceKey context values must appear together.');
+        if (context.has('connection') && connection === undefined)
+            throw new Error('select-next-stage connector connection must reference a root binding.');
+        if (context.has('folderKey') && folder === undefined)
+            throw new Error('select-next-stage connector folderKey must reference a root binding.');
+        connectorSource = opts([
+            ['connectorKey', str(connectorKey)],
+            ['operation', str(operation)],
+            ['connection', connection !== undefined ? str(connection) : undefined],
+            ['folder', folder !== undefined ? str(folder) : undefined],
+        ]);
+    }
+    const exits = (plan.nodes ?? []).filter(isStage)
+        .flatMap((stage) => stage.data?.exitConditions ?? [])
+        .filter((condition) => condition.type === 'wait-for-user');
+    if (exits.length !== 1)
+        throw new Error(`select-next-stage connector requires exactly one wait-for-user exit; found ${exits.length}.`);
+    return new Map([[exits[0], opts([
+                ['objectName', str(objectName)],
+                ['connector', connectorSource],
+            ])]]);
+}
+function connectorVersion(context) {
+    const metadata = context.get('metadata')?.body;
+    const encoded = metadata?.activityPropertyConfiguration?.configuration;
+    if (typeof encoded === 'string' && encoded.startsWith('=jsonString:')) {
+        try {
+            return JSON.parse(encoded.slice('=jsonString:'.length))?.essentialConfiguration?.packageVersion;
+        }
+        catch {
+            throw new Error('connector task has malformed activity metadata configuration JSON.');
+        }
+    }
+    const activity = metadata?.activityMetadata?.activity?.configuration;
+    if (typeof activity === 'string') {
+        try {
+            return JSON.parse(activity)?.version;
+        }
+        catch {
+            throw new Error('connector task has malformed activity configuration JSON.');
+        }
+    }
+    return undefined;
+}
+function toCamel(value) {
+    return value.replace(/_([a-z0-9])/gi, (_match, char) => String(char).toUpperCase());
+}
+function connectorCall(task, refs, library) {
+    if (!library)
+        throw new Error(`connector task "${task.displayName ?? task.id ?? '?'}" needs the connector library; pass DecompileOptions.library or --library.`);
+    const data = task.data ?? {};
+    const context = contextMap({ context: data.context });
+    const connectorKey = context.get('connectorKey')?.value;
+    const method = context.get('method')?.value;
+    const endpoint = context.get('path')?.value;
+    const objectName = context.get('objectName')?.value;
+    if ([connectorKey, method, endpoint, objectName].some((value) => typeof value !== 'string'))
+        throw new Error(`connector task "${task.displayName ?? task.id ?? '?'}" has an incomplete resolved context.`);
+    const identity = library.identifyAction({
+        connectorKey: String(connectorKey),
+        httpMethod: String(method),
+        endpoint: String(endpoint),
+        objectName: String(objectName),
+        version: connectorVersion(context),
+    });
+    const resolved = library.resolve(identity.key, identity.action, identity.version, identity.object);
+    const parameterByWireName = new Map();
+    for (const parameter of resolved.entry.operation?.parameters ?? [])
+        parameterByWireName.set(toCamel(String(parameter.name)), String(parameter.name));
+    const inputs = {};
+    for (const slot of Array.isArray(data.inputs) ? data.inputs : []) {
+        const body = slot?.body;
+        if (!body || typeof body !== 'object' || Array.isArray(body))
+            continue;
+        for (const [wireName, value] of Object.entries(body)) {
+            const authoredName = slot.name === 'body' ? wireName : (parameterByWireName.get(wireName) ?? wireName);
+            inputs[authoredName] = value;
+        }
+    }
+    const connection = bindingName(context.get('connection')?.value, refs);
+    const folder = bindingName(context.get('folderKey')?.value, refs);
+    const options = opts([
+        ['connection', connection !== undefined ? str(connection) : undefined],
+        ['folder', folder !== undefined ? str(folder) : undefined],
+        ['version', identity.version !== '1.0.0' ? str(identity.version) : undefined],
+        ['object', identity.object !== undefined ? str(identity.object) : undefined],
+    ]);
+    return `.connector(${str(identity.key)}, ${str(identity.action)}, ${literal(inputs)}${options ? `, ${options}` : ''})`;
+}
+function externalCall(task, refs, library) {
+    const kind = task.type;
+    const owner = `${kind} task "${task.displayName ?? task.id ?? '?'}"`;
+    if (!library)
+        throw new Error(`${owner} needs the connector library; pass DecompileOptions.library or --library.`);
+    const data = task.data ?? {};
+    const allowed = new Set(['serviceType', 'context', 'inputs', 'outputs', 'bindings']);
+    const unknownData = Object.keys(data).find((name) => !allowed.has(name));
+    if (unknownData)
+        throw new Error(`${owner} has unsupported data field "${unknownData}".`);
+    if (!Array.isArray(data.bindings) || data.bindings.length !== 0)
+        throw new Error(`${owner} data.bindings must be an empty array; bindings live at case root.`);
+    const modes = kind === 'external-agent'
+        ? new Map([
+            [CASE_FORMAT_PROFILE.externalAgentSyncServiceType, 'sync'],
+            [CASE_FORMAT_PROFILE.externalAgentAsyncServiceType, 'async'],
+        ])
+        : new Map([
+            [CASE_FORMAT_PROFILE.externalWorkflowSyncServiceType, 'sync'],
+            [CASE_FORMAT_PROFILE.externalWorkflowAsyncServiceType, 'async'],
+        ]);
+    const mode = modes.get(data.serviceType);
+    if (!mode)
+        throw new Error(`${owner} has unsupported serviceType "${String(data.serviceType ?? '')}".`);
+    if (!Array.isArray(data.context))
+        throw new Error(`${owner} requires a resolved context array.`);
+    const expectedContext = ['activity', 'connectorKey', 'connection', 'folderKey', 'method', 'path'];
+    if (data.context.map((row) => row.name).join('\0') !== expectedContext.join('\0'))
+        throw new Error(`${owner} context must contain exactly ${expectedContext.join(', ')} in canonical order.`);
+    const context = contextMap(data);
+    const stringValue = (name) => {
+        const row = context.get(name);
+        if (row?.type !== 'string' || typeof row.value !== 'string' || !row.value)
+            throw new Error(`${owner} context ${name} must be a non-empty string.`);
+        return row.value;
+    };
+    const binding = (name) => {
+        const value = stringValue(name);
+        if (!value.startsWith('=bindings.'))
+            throw new Error(`${owner} context ${name} must reference a root binding.`);
+        const id = value.slice('=bindings.'.length);
+        if (!refs.bindingById.has(id))
+            throw new Error(`${owner} context ${name} references missing root binding "${id}".`);
+        return id;
+    };
+    const identity = library.identifyAction({
+        connectorKey: stringValue('connectorKey'),
+        httpMethod: stringValue('method'),
+        endpoint: stringValue('path'),
+    });
+    const resolved = library.resolve(identity.key, identity.action, identity.version, identity.object);
+    const expectedSubType = kind === 'external-agent' ? 'AgentExecution' : 'ProcessExecution';
+    if (resolved.entry.operation?.subType !== expectedSubType)
+        throw new Error(`${owner} resolves to ${String(resolved.entry.operation?.subType ?? 'no subtype')}, not ${expectedSubType}.`);
+    if (stringValue('activity') !== resolved.activityTypeId)
+        throw new Error(`${owner} activity does not match its descriptor.`);
+    if (!Array.isArray(data.inputs))
+        throw new Error(`${owner} inputs must be an array.`);
+    const fields = new Map(resolved.fields.map((field) => [field.name, field]));
+    const inputs = {};
+    for (const row of data.inputs) {
+        const name = String(row?.name ?? '');
+        if (!name || row.id !== name || row.target !== name || !fields.has(name))
+            throw new Error(`${owner} has unsupported input row "${name}".`);
+        inputs[name] = row.value;
+    }
+    const missing = resolved.fields.find((field) => field.required && !(field.name in inputs));
+    if (missing)
+        throw new Error(`${owner} is missing required input "${missing.name}".`);
+    if (!Array.isArray(data.outputs) || data.outputs.length !== 1)
+        throw new Error(`${owner} must carry exactly one response output.`);
+    const output = data.outputs[0];
+    if (output.name !== 'response' || output.type !== 'json' || output.source !== '.'
+        || typeof output.var !== 'string' || output.id !== output.var)
+        throw new Error(`${owner} has an unsupported response output.`);
+    const descriptor = `{ nodeType: ${str(resolved.nodeType)}, version: ${str(resolved.version)} }`;
+    const options = opts([
+        ['connection', str(binding('connection'))],
+        ['folder', str(binding('folderKey'))],
+        ['mode', str(mode)],
+        ['inputs', literal(inputs)],
+    ]);
+    const method = kind === 'external-agent' ? 'externalAgent' : 'externalWorkflow';
+    return `.${method}(${descriptor}, ${options})`;
+}
+function emitTaskKind(task, refs, library) {
+    const kind = task.type;
+    const data = task.data ?? {};
+    if (TASK_KIND_METHOD[kind]) {
+        if (kind !== 'flow-process' && data.name === undefined && data.folderPath === undefined) {
+            if ((Array.isArray(data.inputs) && data.inputs.length) || (Array.isArray(data.outputs) && data.outputs.length))
+                throw new Error(`unresolved ${kind} task "${task.displayName ?? task.id ?? '?'}" cannot carry input or output bindings.`);
+            return `.unresolved(${str(kind)})`;
+        }
+        const name = bindingDefault(data.name, refs);
+        const folderPath = bindingDefault(data.folderPath, refs);
+        const folder = folderPath ? `, ${opts([['folder', str(folderPath)]])}` : '';
+        return `.${TASK_KIND_METHOD[kind]}(${str(name ?? '')}${folder})`;
+    }
+    if (kind === 'action') {
+        let recipient;
+        if (data.recipient) {
+            const type = Number(data.recipient.Type);
+            if (!Number.isFinite(type))
+                throw new Error(`task recipient has a non-numeric type "${data.recipient.Type}".`);
+            recipient = type === 2
+                ? str(data.recipient.Value)
+                : opts([['type', String(type)], ['value', str(data.recipient.Value)]]);
+        }
+        const spec = opts([
+            ['title', data.taskTitle !== undefined ? str(data.taskTitle) : undefined],
+            ['priority', data.priority && data.priority !== 'Medium' ? str(data.priority) : undefined],
+            ['recipient', recipient],
+            ['labels', data.labels !== undefined ? str(data.labels) : undefined],
+            ['actionCatalogName', data.actionCatalogName !== undefined ? str(data.actionCatalogName) : undefined],
+            ['inputs', actionFields(data.inputs)],
+            ['outputs', actionFields(data.outputs)],
+        ]);
+        return `.action(${spec})`;
+    }
+    if (kind === 'execute-connector-activity')
+        return connectorCall(task, refs, library);
+    if (kind === 'external-agent' || kind === 'external-workflow')
+        return externalCall(task, refs, library);
+    if (kind === 'wait-for-timer') {
+        const spec = opts([
+            ['duration', data.timeDuration !== undefined ? str(data.timeDuration) : undefined],
+            ['date', data.timeDate !== undefined ? str(data.timeDate) : undefined],
+            ['cycle', data.timeCycle !== undefined ? str(data.timeCycle) : undefined],
+        ]);
+        return `.waitForTimer(${spec})`;
+    }
+    if (kind === 'wait-for-connector') {
+        const spec = waitConnectorSpec(data, `wait-for-connector task "${task.displayName ?? task.id ?? '?'}"`, refs);
+        return spec === undefined ? '.waitForConnector()' : `.waitForConnector(${spec})`;
+    }
+    const message = `unsupported task kind "${kind}" for task "${task.displayName ?? task.id ?? '?'}".`;
+    diagnose(refs, {
+        code: 'UNSUPPORTED_TASK_KIND',
+        message,
+        location: `task:${task.id ?? task.displayName ?? '?'}`,
+    });
+    return `.__UNRESOLVED_TASK_KIND__(${str(kind)}, ${literal(data)})`;
+}
+function ioArg(rows, kind) {
+    const valueField = kind === 'inputs' ? 'value' : 'source';
+    const entries = rows.map((row) => {
+        const name = kind === 'inputs' ? row.name : row.var;
+        const value = str(row[valueField] ?? '');
+        const cell = row.type && row.type !== 'string'
+            ? `{ ${valueField}: ${value}, type: ${str(row.type)} }`
+            : value;
+        return `${key(String(name ?? ''))}: ${cell}`;
+    });
+    return `{ ${entries.join(', ')} }`;
+}
+function emitTask(out, depth, task, lane, refs, library) {
+    out.line(depth, `.task(${str(task.displayName ?? '')}, t => t`);
+    const inner = depth + 1;
+    out.line(inner, emitTaskKind(task, refs, library));
+    if (TASK_KIND_METHOD[task.type]) {
+        const data = task.data ?? {};
+        if (Array.isArray(data.inputs) && data.inputs.length)
+            out.line(inner, `.inputs(${ioArg(data.inputs, 'inputs')})`);
+        if (Array.isArray(data.outputs) && data.outputs.length)
+            out.line(inner, `.outputs(${ioArg(data.outputs, 'outputs')})`);
+    }
+    if (task.isRequired !== undefined)
+        out.line(inner, task.isRequired ? '.required()' : '.required(false)');
+    if (task.shouldRunOnlyOnce !== undefined)
+        out.line(inner, task.shouldRunOnlyOnce ? '.runOnce()' : '.runOnReEntry()');
+    if (task.description)
+        out.line(inner, `.description(${str(task.description)})`);
+    if (task.skipCondition)
+        out.line(inner, `.skipWhen(${str(task.skipCondition)})`);
+    for (const condition of task.entryConditions ?? [])
+        emitEntryWhen(out, inner, condition, refs, false);
+    out.line(depth, lane > 0 ? `, ${opts([['lane', String(lane)]])})` : ')');
+}
+function escalationSource(escalation, slaName, index) {
+    if (escalation.action?.type !== 'notification')
+        throw new Error(`SLA escalation "${escalation.displayName ?? escalation.id ?? index}" has unsupported action "${escalation.action?.type}".`);
+    const recipients = escalation.action.recipients ?? [];
+    if (recipients.length === 0)
+        throw new Error(`SLA escalation "${escalation.displayName ?? escalation.id ?? index}" has no notification recipients.`);
+    const notify = recipients.map((recipient) => {
+        if (recipient.scope !== 'User' && recipient.scope !== 'UserGroup')
+            throw new Error(`SLA escalation "${escalation.displayName ?? escalation.id ?? index}" has unsupported recipient scope "${recipient.scope}".`);
+        const helper = recipient.scope === 'User' ? 'toUser' : 'toGroup';
+        const target = recipient.target ?? '';
+        const value = recipient.value !== undefined && recipient.value !== target ? `, ${str(recipient.value)}` : '';
+        return `${helper}(${str(target)}${value})`;
+    });
+    const generatedName = `Escalation rule ${index + 1} - ${slaName}`;
+    const trigger = escalation.triggerInfo?.type;
+    if (trigger !== 'at-risk' && trigger !== 'sla-breached')
+        throw new Error(`SLA escalation "${escalation.displayName ?? escalation.id ?? index}" has unsupported trigger "${trigger}".`);
+    return `escalation(${opts([
+        ['displayName', escalation.displayName && escalation.displayName !== generatedName ? str(escalation.displayName) : undefined],
+        ['trigger', str(trigger)],
+        ['atRiskPercentage', trigger === 'at-risk' && escalation.triggerInfo?.atRiskPercentage !== undefined
+                ? String(escalation.triggerInfo.atRiskPercentage)
+                : undefined],
+        ['notify', `[${notify.join(', ')}]`],
+    ])})`;
+}
+function slaSource(sla, index) {
+    const displayName = sla.displayName ?? `SLA ${index + 1}`;
+    const escalations = (sla.escalationRule ?? []).map((entry, escalationIndex) => escalationSource(entry, displayName, escalationIndex));
+    return opts([
+        ['displayName', sla.displayName !== undefined ? str(sla.displayName) : undefined],
+        ['count', sla.count !== undefined ? String(sla.count) : undefined],
+        ['unit', sla.unit !== undefined ? str(sla.unit) : undefined],
+        ['when', sla.expression !== undefined && sla.expression !== '=js:true' ? str(sla.expression) : undefined],
+        ['escalations', escalations.length ? `[${escalations.join(', ')}]` : undefined],
+    ]);
+}
+function emitStage(out, depth, stage, refs, library, selectNextStage) {
+    const exception = stage.type.endsWith('ExceptionStage') || stage.stageType === 'secondary' || stage.data?.stageType === 'secondary';
+    const data = stage.data ?? {};
+    out.line(depth, `.${exception ? 'exceptionStage' : 'stage'}(${str(data.label ?? '')}, s => s`);
+    const inner = depth + 1;
+    if (data.description)
+        out.line(inner, `.description(${str(data.description)})`);
+    if (data.isRequired !== undefined)
+        out.line(inner, data.isRequired ? '.required()' : '.required(false)');
+    for (const condition of data.entryConditions ?? [])
+        emitEntryWhen(out, inner, condition, refs, true);
+    const lanes = data.tasks ?? [];
+    lanes.forEach((lane, laneIndex) => lane.forEach((task) => emitTask(out, inner, task, laneIndex, refs, library)));
+    (data.slaRules ?? []).forEach((sla, index) => out.line(inner, `.sla(${slaSource(sla, index)})`));
+    for (const condition of data.exitConditions ?? [])
+        emitExitWhen(out, inner, condition, refs, selectNextStage.get(condition));
+    out.line(depth, ')');
+}
+function varSpec(entry) {
+    const body = entry.body ?? entry._jsonSchema;
+    if (entry.type === 'jsonSchema' && body !== undefined && entry.default === undefined)
+        return `jsonSchema(${literal(body)})`;
+    if (entry.default !== undefined || (entry.type === 'jsonSchema' && body !== undefined)) {
+        return opts([
+            ['type', str(entry.type)],
+            ['default', entry.default !== undefined ? literal(entry.default) : undefined],
+            ['body', entry.type === 'jsonSchema' && body !== undefined ? literal(body) : undefined],
+        ]);
+    }
+    return str(entry.type);
+}
+function isResolvedConnectorOutput(row, triggerId, resolved) {
+    if (!resolved || row.elementId !== triggerId)
+        return false;
+    return (row.name === 'response' && /^=response\d*$/.test(String(row.source ?? '')))
+        || (row.name === 'Error' && /^=Error\d*$/.test(String(row.source ?? '')));
+}
+function producedVariableNames(plan) {
+    const produced = new Set();
+    for (const node of plan.nodes ?? []) {
+        if (isTrigger(node)) {
+            const { bag } = triggerData(node);
+            const bridges = bridgeRows(plan, node.id ?? '', bag);
+            const resolved = (bag?.context?.length ?? 0) > 2;
+            for (const row of bag?.outputs ?? [])
+                if (!bridges.has(row) && !isResolvedConnectorOutput(row, node.id ?? '', resolved) && row.var)
+                    produced.add(row.var);
+            continue;
+        }
+        if (!isStage(node))
+            continue;
+        for (const lane of node.data?.tasks ?? [])
+            for (const task of lane)
+                if (TASK_KIND_METHOD[task.type])
+                    for (const row of task.data?.outputs ?? [])
+                        if (row.var)
+                            produced.add(row.var);
+    }
+    return produced;
+}
+function emitVariables(out, depth, plan, triggerNameById) {
+    const variables = plan.variables ?? {};
+    const produced = producedVariableNames(plan);
+    for (const input of variables.inputs ?? []) {
+        const from = input.elementId && triggerNameById.get(input.elementId);
+        const fromOpts = from ? `, { from: ${from} }` : '';
+        out.line(depth, `.input({ ${key(input.name)}: ${varSpec(input)} }${fromOpts})`);
+    }
+    for (const output of variables.outputs ?? [])
+        out.line(depth, `.output({ ${key(output.name)}: ${varSpec(output)} })`);
+    const declaredElsewhere = new Set([...(variables.inputs ?? []), ...(variables.outputs ?? [])].map((entry) => entry.name));
+    for (const variable of variables.inputOutputs ?? []) {
+        if (declaredElsewhere.has(variable.name) || (variable.custom && produced.has(variable.name)))
+            continue;
+        const body = variable.body ?? variable._jsonSchema;
+        const type = variable.type === 'jsonSchema' && body !== undefined
+            ? `jsonSchema(${literal(body)})`
+            : str(variable.type);
+        const defaultValue = variable.default !== undefined ? `, ${literal(variable.default)}` : '';
+        out.line(depth, `.var(${str(variable.name)}, ${type}${defaultValue})`);
+    }
+}
+function triggerData(node) {
+    const data = node.data ?? {};
+    if (node.type === 'uipath.case.trigger') {
+        return {
+            label: data.display?.label,
+            description: data.description ?? data.display?.description,
+            bag: data.inputs,
+        };
+    }
+    return { label: data.label, description: data.description, bag: data.uipath };
+}
+function bridgeRows(plan, triggerId, bag) {
+    const inputs = (plan.variables?.inputs ?? []).filter((entry) => entry.elementId === triggerId);
+    const bridges = new Set();
+    for (const row of bag?.outputs ?? []) {
+        if (inputs.some((input) => row.var === input.name && row.source === `=vars.${input.id}`))
+            bridges.add(row);
+    }
+    return bridges;
+}
+function triggerSource(node, index, plan, refs) {
+    const { label, description, bag } = triggerData(node);
+    const name = label !== `Trigger ${index + 1}` ? str(label) : undefined;
+    if (!bag?.serviceType || bag.serviceType === 'None')
+        return `manualTrigger(${opts([['name', name], ['description', description ? str(description) : undefined]])})`;
+    if (bag.serviceType === 'Intsvc.TimerTrigger' || bag.serviceType === 'timer') {
+        if (bag.timerType !== undefined && bag.timerType !== 'timeCycle')
+            throw new Error(`timer trigger "${label ?? node.id ?? index}" has unsupported timerType "${bag.timerType}".`);
+        return `timerTrigger(${opts([
+            ['every', bag.timeCycle !== undefined ? str(bag.timeCycle) : undefined],
+            ['name', name],
+            ['description', description ? str(description) : undefined],
+        ])})`;
+    }
+    if (bag.serviceType === 'Intsvc.EventTrigger') {
+        const bridges = bridgeRows(plan, node.id ?? '', bag);
+        const resolved = bag.context !== undefined || bag.inputs !== undefined || bag.bindings !== undefined;
+        const outputs = (bag.outputs ?? []).filter((row) => !bridges.has(row) && !isResolvedConnectorOutput(row, node.id ?? '', resolved));
+        const subscription = resolved
+            ? resolvedSubscriptionSource(bag, `event trigger "${label ?? node.id ?? index}"`, 'trigger', refs)
+            : undefined;
+        const outputShape = outputs.length
+            ? `{ ${outputs.map((row) => {
+                const source = str(row.source ?? '');
+                const cell = row.type && row.type !== 'string'
+                    ? `{ source: ${source}, type: ${str(row.type)} }`
+                    : source;
+                return `${key(String(row.var ?? row.name ?? ''))}: ${cell}`;
+            }).join(', ')} }`
+            : undefined;
+        return `eventTrigger(${opts([
+            ['name', name],
+            ['description', description ? str(description) : undefined],
+            ['subscription', subscription],
+            ['outputs', outputShape],
+        ])})`;
+    }
+    throw new Error(`trigger "${label ?? node.id ?? index}" has unsupported serviceType "${bag.serviceType}".`);
+}
+function caseAppSource(config) {
+    if (typeof config.caseSummary !== 'string')
+        throw new Error('caseAppConfig.caseSummary must be a string.');
+    if (!Array.isArray(config.sections))
+        throw new Error('caseAppConfig.sections must be an array.');
+    const sections = config.sections.map((section, index) => {
+        if (typeof section.id !== 'string' || typeof section.title !== 'string' || typeof section.details !== 'string')
+            throw new Error(`caseAppConfig section ${index + 1} must have string id, title, and details fields.`);
+        let details;
+        try {
+            details = JSON.parse(section.details);
+        }
+        catch {
+            throw new Error(`caseAppConfig section "${section.title}" details is not a JSON-encoded object.`);
+        }
+        if (!details || typeof details !== 'object' || Array.isArray(details))
+            throw new Error(`caseAppConfig section "${section.title}" details is not a JSON-encoded object.`);
+        const entries = Object.entries(details);
+        if (entries.length > 6)
+            throw new Error(`caseAppConfig section "${section.title}" details has more than 6 entries.`);
+        const nested = entries.find(([, value]) => value !== null && !['string', 'number', 'boolean'].includes(typeof value));
+        if (nested)
+            throw new Error(`caseAppConfig section "${section.title}" detail "${nested[0]}" is not primitive.`);
+        return { id: section.id, title: section.title, details };
+    });
+    return literal({ summary: config.caseSummary, sections });
+}
+function refuseUnsupportedAuthoring(plan) {
+    if (plan.metadata?.adhocCaseEndData !== undefined)
+        throw new Error('adhocCaseEndData is a legacy Case Manager field and is unavailable at the V30 authoring floor.');
+    for (const node of plan.nodes ?? []) {
+        if (!isStage(node))
+            continue;
+        if (node.data?.adhocOrchestrationData !== undefined)
+            throw new Error(`stage "${node.data.label ?? node.id ?? '?'}" has legacy adhocOrchestrationData, which is unavailable at the V30 authoring floor.`);
+        if (node.data?.adhocCaseEndData !== undefined)
+            throw new Error(`stage "${node.data.label ?? node.id ?? '?'}" has legacy adhocCaseEndData, which is unavailable at the V30 authoring floor.`);
+        for (const lane of node.data?.tasks ?? []) {
+            for (const task of lane) {
+                if (task.conditions !== undefined || task.data?.conditions !== undefined)
+                    throw new Error(`task "${task.displayName ?? task.id ?? '?'}" has a conditions[] grid, which the current-floor converter retains but does not execute.`);
+                if (task.nonSequentialRunConditions !== undefined || task.data?.nonSequentialRunConditions !== undefined)
+                    throw new Error(`task "${task.displayName ?? task.id ?? '?'}" has nonSequentialRunConditions, which is absent from the current task schema and does not affect scheduler rules.`);
+            }
+        }
+    }
+}
+function conditionIdentity(condition) {
+    return {
+        ...(condition.id ? { id: condition.id } : {}),
+        rules: (condition.rules ?? []).map((group) => group.map((rule) => ({ ...(rule.id ? { id: rule.id } : {}) }))),
+    };
+}
+function slaIdentity(sla) {
+    return {
+        ...(sla.id ? { id: sla.id } : {}),
+        escalations: (sla.escalationRule ?? []).map((entry) => ({ ...(entry.id ? { id: entry.id } : {}) })),
+    };
+}
+function identityPreservation(plan) {
+    return {
+        ...(plan.id ? { id: plan.id } : {}),
+        triggers: (plan.nodes ?? []).filter(isTrigger).map((node) => ({ ...(node.id ? { id: node.id } : {}) })),
+        stages: (plan.nodes ?? []).filter(isStage).map((stage) => ({
+            label: stage.data?.label ?? '',
+            ...(stage.id ? { id: stage.id } : {}),
+            tasks: (stage.data?.tasks ?? []).map((lane) => lane.map((task) => ({
+                name: task.displayName ?? '',
+                ...(task.id ? { id: task.id } : {}),
+                entryConditions: (task.entryConditions ?? []).map(conditionIdentity),
+                inputs: (task.data?.inputs ?? []).map((row) => ({ name: row.name ?? '', ...(row.id ? { id: row.id } : {}) })),
+                outputs: (task.data?.outputs ?? []).map((row) => ({ name: row.name ?? '', ...(row.id ? { id: row.id } : {}) })),
+            }))),
+            entryConditions: (stage.data?.entryConditions ?? []).map(conditionIdentity),
+            exitConditions: (stage.data?.exitConditions ?? []).map(conditionIdentity),
+            slaRules: (stage.data?.slaRules ?? []).map(slaIdentity),
+        })),
+        caseExitRules: (plan.metadata?.caseExitRules ?? []).map(conditionIdentity),
+        slaRules: (plan.metadata?.slaRules ?? []).map(slaIdentity),
+        variables: Object.fromEntries(['inputs', 'outputs', 'inputOutputs'].map((lane) => [
+            lane,
+            (plan.variables?.[lane] ?? []).map((row) => ({ name: row.name, ...(row.id ? { id: row.id } : {}) })),
+        ])),
+    };
+}
+function collectPreservation(plan) {
+    const preservation = { identities: identityPreservation(plan) };
+    const topKnown = new Set(['id', 'name', 'description', 'version', 'bindings', 'variables', 'metadata', 'nodes', 'edges', 'layout']);
+    const topLevel = Object.fromEntries(Object.entries(plan).filter(([name]) => !topKnown.has(name)));
+    if (Object.keys(topLevel).length)
+        preservation.topLevel = topLevel;
+    const metadataKnown = new Set([
+        'caseIdentifier', 'caseIdentifierType', 'caseAppEnabled', 'caseAppConfig', 'publishVersion', 'caseExitRules', 'slaRules',
+        'allowAdhocOptionalStageTasks', 'waitForHumanSelectNextStageDFConnector',
+    ]);
+    const metadata = Object.fromEntries(Object.entries(plan.metadata ?? {}).filter(([name]) => !metadataKnown.has(name)));
+    if (Object.keys(metadata).length)
+        preservation.metadata = metadata;
+    const caseAppConfig = plan.metadata?.caseAppConfig;
+    if (caseAppConfig) {
+        const known = new Set(['caseSummary', 'sections', 'stageOrder', 'hiddenStageIds']);
+        const unknown = Object.keys(caseAppConfig).filter((name) => !known.has(name));
+        if (unknown.length)
+            throw new Error(`caseAppConfig has unsupported field "${unknown[0]}", which is not authorable.`);
+        const fields = Object.fromEntries(['stageOrder', 'hiddenStageIds']
+            .filter((name) => Object.prototype.hasOwnProperty.call(caseAppConfig, name))
+            .map((name) => [name, caseAppConfig[name]]));
+        const sections = (Array.isArray(caseAppConfig.sections) ? caseAppConfig.sections : []).flatMap((section) => {
+            if (!section || typeof section !== 'object')
+                return [];
+            const sectionKnown = new Set(['id', 'title', 'details', 'error', 'titleError']);
+            const sectionUnknown = Object.keys(section).filter((name) => !sectionKnown.has(name));
+            if (sectionUnknown.length)
+                throw new Error(`caseAppConfig section has unsupported field "${sectionUnknown[0]}", which is not authorable.`);
+            const preservedFields = Object.fromEntries(['error', 'titleError']
+                .filter((name) => Object.prototype.hasOwnProperty.call(section, name))
+                .map((name) => [name, section[name]]));
+            return typeof section.id === 'string' && Object.keys(preservedFields).length
+                ? [{ id: section.id, fields: preservedFields }]
+                : [];
+        });
+        if (Object.keys(fields).length || sections.length)
+            preservation.caseAppConfigFields = {
+                ...(Object.keys(fields).length ? { fields } : {}),
+                ...(sections.length ? { sections } : {}),
+            };
+    }
+    const preservedNodes = [];
+    (plan.nodes ?? []).forEach((node, index) => {
+        if (isStage(node) || isTrigger(node))
+            return;
+        if (node.type !== 'case-management:StickyNote')
+            throw new Error(`unsupported top-level node construct "${node.type ?? '(missing)'}".`);
+        preservedNodes.push({ index, node });
+    });
+    if (preservedNodes.length)
+        preservation.nodes = preservedNodes;
+    const nodeOrder = (plan.nodes ?? []).flatMap((node) => typeof node.id === 'string' ? [node.id] : []);
+    if (nodeOrder.length)
+        preservation.nodeOrder = nodeOrder;
+    if ((plan.edges?.length ?? 0) > 0)
+        preservation.edges = plan.edges;
+    if (Object.prototype.hasOwnProperty.call(plan, 'layout'))
+        preservation.layout = plan.layout;
+    else {
+        const inlineLayout = Object.fromEntries((plan.nodes ?? []).flatMap((node) => {
+            const positioned = node;
+            return positioned.id && positioned.position !== undefined
+                ? [[positioned.id, { position: positioned.position }]]
+                : [];
+        }));
+        if (Object.keys(inlineLayout).length)
+            preservation.layout = { nodes: inlineLayout };
+        else
+            preservation.omitLayout = true;
+    }
+    const triggerDataKnown = new Set(['label', 'description', 'uipath', 'display', 'inputs', 'typeVersion']);
+    const triggerDataPreserved = new Set(['parentElement', 'isInvalidDropTarget', 'isPendingParent']);
+    const triggerDataFields = (plan.nodes ?? []).filter(isTrigger).map((trigger) => Object.fromEntries(Object.entries(trigger.data ?? {}).filter(([name]) => !triggerDataKnown.has(name))));
+    for (const [index, fields] of triggerDataFields.entries())
+        for (const field of Object.keys(fields))
+            if (!triggerDataPreserved.has(field))
+                throw new Error(`trigger ${index + 1} has unsupported data field "${field}", which is not allowed in the collision-refusing preservation channel.`);
+    if (triggerDataFields.some((fields) => Object.keys(fields).length))
+        preservation.triggerDataFields = triggerDataFields;
+    const taskKnown = new Set([
+        'id', 'displayName', 'type', 'data', 'shouldRunOnlyOnce', 'isRequired', 'skipCondition', 'description',
+        'entryConditions', 'conditions', 'nonSequentialRunConditions',
+    ]);
+    const taskFields = [];
+    const omitTaskElementIds = [];
+    const omitStagePositions = [];
+    for (const stage of (plan.nodes ?? []).filter(isStage)) {
+        const label = stage.data?.label ?? '';
+        if (!Object.prototype.hasOwnProperty.call(stage, 'position'))
+            omitStagePositions.push(label);
+        (stage.data?.tasks ?? []).forEach((lane, laneIndex) => lane.forEach((task) => {
+            // `elementId` is serializer-owned for every task now, so it is dropped
+            // here rather than preserved: `compile` reconstructs the same
+            // `<stageId>-<taskId>` from ids preservation already pins, and writing it
+            // through the channel too would be a redundant write of a value the
+            // serializer owns. Anything else unrecognised on a task has no home.
+            // A source document that carries no `elementId` must not gain one: see
+            // `omitTaskElementIds` in preserve.ts.
+            if (!Object.prototype.hasOwnProperty.call(task, 'elementId'))
+                omitTaskElementIds.push({ stage: label, lane: laneIndex, task: task.displayName ?? '' });
+            const fields = Object.fromEntries(Object.entries(task).filter(([name]) => !taskKnown.has(name) && name !== 'elementId'));
+            for (const field of Object.keys(fields))
+                throw new Error(`task "${task.displayName ?? task.id ?? '?'}" has unsupported field "${field}", which is not allowed in the collision-refusing preservation channel.`);
+            if (Object.keys(fields).length)
+                taskFields.push({ stage: label, lane: laneIndex, task: task.displayName ?? '', fields });
+        }));
+    }
+    if (taskFields.length)
+        preservation.taskFields = taskFields;
+    if (omitTaskElementIds.length)
+        preservation.omitTaskElementIds = omitTaskElementIds;
+    if (omitStagePositions.length)
+        preservation.omitStagePositions = omitStagePositions;
+    const produced = producedVariableNames(plan);
+    const variableKnown = new Set(['id', 'name', 'type', 'default', 'body', '_jsonSchema', 'elementId', 'var', 'custom']);
+    const variableFields = {};
+    const legacyVariableDefaults = {};
+    const variableOrder = {};
+    for (const lane of ['inputs', 'outputs', 'inputOutputs']) {
+        const rows = plan.variables?.[lane] ?? [];
+        if (rows.length)
+            variableOrder[lane] = rows.map((row) => row.name);
+        const byName = {};
+        const defaultsByName = {};
+        for (const row of rows) {
+            const fields = Object.fromEntries(Object.entries(row).filter(([name]) => !variableKnown.has(name)));
+            for (const field of Object.keys(fields))
+                if (!['subType', 'canonicalId', 'camelizedId', 'variableType', 'internal'].includes(field))
+                    throw new Error(`variable "${row.name}" has unsupported field "${field}", which is not allowed in the collision-refusing preservation channel.`);
+            if (lane === 'inputOutputs' && row.custom && !produced.has(row.name))
+                fields.custom = true;
+            const formalOutput = (plan.variables?.outputs ?? []).find((candidate) => candidate.name === row.name);
+            if (lane === 'inputOutputs' && formalOutput && row.default !== undefined && formalOutput.default !== row.default)
+                fields.default = row.default;
+            if (lane === 'outputs' && row.var !== undefined)
+                fields.var = row.var;
+            if (Object.keys(fields).length)
+                byName[row.name] = fields;
+            if (row.default !== undefined && typeof row.default !== 'string')
+                defaultsByName[row.name] = row.default;
+        }
+        if (Object.keys(byName).length)
+            variableFields[lane] = byName;
+        if (Object.keys(defaultsByName).length)
+            legacyVariableDefaults[lane] = defaultsByName;
+    }
+    if (Object.keys(variableFields).length)
+        preservation.variableFields = variableFields;
+    if (Object.keys(legacyVariableDefaults).length)
+        preservation.legacyVariableDefaults = legacyVariableDefaults;
+    if (Object.keys(variableOrder).length)
+        preservation.variableOrder = variableOrder;
+    return Object.keys(preservation).length ? preservation : undefined;
+}
+function slugId(plan) {
+    if (plan.id && /^case-[A-Za-z0-9]{10}$/.test(plan.id))
+        return plan.id;
+    const base = plan.name ?? plan.id ?? 'case';
+    return base.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'case';
+}
+export function decompileWithDiagnostics(plan, options = {}) {
+    const diagnostics = [];
+    refuseUnsupportedAuthoring(plan);
+    const preservation = collectPreservation(plan);
+    const refs = buildRefs(plan, options.library, options.bestEffort ? diagnostics : undefined);
+    const selectNextStage = selectNextStageByExit(plan, refs);
+    const metadata = plan.metadata ?? {};
+    const triggers = (plan.nodes ?? []).filter(isTrigger);
+    const triggerNameById = new Map();
+    const out = new Emit();
+    triggers.forEach((trigger, index) => {
+        const variableName = `trigger${index + 1}`;
+        if (trigger.id)
+            triggerNameById.set(trigger.id, variableName);
+        out.line(0, `const ${variableName} = ${triggerSource(trigger, index, plan, refs)};`);
+    });
+    if (triggers.length)
+        out.line(0, '');
+    out.line(0, `${preservation ? 'const caseDefinition =' : 'export default'} casePlan(${str(slugId(plan))})`);
+    const depth = 1;
+    // The declared grammar version first, mirroring the document's own key order
+    // and emitted even when it equals this SDK's write version: preserving means
+    // RE-DECLARING, so a later write-floor bump cannot silently upgrade a plan a
+    // decompile already captured. A version this build cannot write is reported in
+    // the source instead of being dropped — the source still compiles (it writes
+    // the SDK's version), which is why this is a comment rather than one of the
+    // repair diagnostics that mark a source intentionally unbuildable.
+    const schema = preserveSchemaVersion(CASE_SCHEMA_VERSIONS, plan.version);
+    if (schema.call)
+        out.line(depth, schema.call);
+    if (schema.problem)
+        out.line(depth, `// TODO: ${schema.problem}`);
+    if (plan.name !== undefined)
+        out.line(depth, `.name(${str(plan.name)})`);
+    if (plan.description !== undefined)
+        out.line(depth, `.description(${str(plan.description)})`);
+    if (metadata.caseIdentifier !== undefined) {
+        const type = metadata.caseIdentifierType && metadata.caseIdentifierType !== 'constant'
+            ? `, ${str(metadata.caseIdentifierType)}`
+            : '';
+        out.line(depth, `.identifier(${str(metadata.caseIdentifier)}${type})`);
+    }
+    if (metadata.caseAppConfig !== undefined)
+        out.line(depth, `.caseApp(${caseAppSource(metadata.caseAppConfig)})`);
+    else if (metadata.caseAppEnabled)
+        out.line(depth, '.caseApp()');
+    if (metadata.caseAppConfig !== undefined && metadata.caseAppEnabled === false)
+        out.line(depth, '.caseApp(false)');
+    if (metadata.allowAdhocOptionalStageTasks !== undefined) {
+        if (typeof metadata.allowAdhocOptionalStageTasks !== 'boolean')
+            throw new Error('allowAdhocOptionalStageTasks must be boolean.');
+        out.line(depth, metadata.allowAdhocOptionalStageTasks ? '.allowAdhocTasks()' : '.allowAdhocTasks(false)');
+    }
+    emitVariables(out, depth, plan, triggerNameById);
+    triggers.forEach((_trigger, index) => out.line(depth, `.trigger(trigger${index + 1})`));
+    (metadata.slaRules ?? []).forEach((sla, index) => out.line(depth, `.sla(${slaSource(sla, index)})`));
+    for (const node of plan.nodes ?? [])
+        if (isStage(node))
+            emitStage(out, depth, node, refs, options.library, selectNextStage);
+    for (const condition of metadata.caseExitRules ?? [])
+        emitCompleteWhen(out, depth, condition, refs);
+    out.line(depth, '.build();');
+    if (preservation) {
+        out.line(0, '');
+        out.line(0, `export default preserveCaseJson(caseDefinition, ${literal(preservation)});`);
+    }
+    const imports = ['casePlan', 'rule', 'manualTrigger', 'timerTrigger', 'eventTrigger', 'jsonSchema', 'escalation', 'toUser', 'toGroup'];
+    if (preservation)
+        imports.push('preserveCaseJson');
+    const diagnosticHeader = diagnostics.length
+        ? `${[
+            '// BEST-EFFORT DECOMPILE: this source is intentionally not buildable until every marker below is repaired.',
+            ...diagnostics.map((diagnostic) => `// [${diagnostic.code}] ${diagnostic.location}: ${diagnostic.message}`
+                .replace(/[\r\n]+/g, ' ')),
+        ].join('\n')}\n\n`
+        : '';
+    const source = `import { ${imports.join(', ')} } from ${str(options.importSpecifier ?? './case-sdk.js')};\n\n${diagnosticHeader}${out.toString()}\n`;
+    return { source, diagnostics };
+}
+export function decompile(plan, options = {}) {
+    return decompileWithDiagnostics(plan, options).source;
+}