@uipath/maestro-builder-sdk 6.70.0 → 6.70.2

package/dist/bpmn/decompile.js

@@ -2071,7 +2071,7 @@ defaultScope = () => ownerId) {
             if (skip.has(v.id))
                 continue;
             const type = varType(v.type);
-            const def = v.default === undefined ? undefined : decodeDefault(v.default, v.type);
+            const def = v.default === undefined ? undefined : decodeDefault(v.default, v.type, v.id);
             entries.push(`{ id: ${tsText(v.id)}, type: ${tsText(type)}${inner([
                 ['direction', direction === 'inputOutput' ? undefined : tsText(direction)],
                 ['name', v.name !== undefined && v.name !== v.id ? tsText(v.name) : undefined],
@@ -2118,11 +2118,19 @@ function bindingIsReferenced(xml, id) {
  * anything non-finite, so it was right by accident; this makes the rule explicit for
  * every type.
  */
-function decodeDefault(raw, wire) {
+function decodeDefault(raw, wire, id) {
     if (raw.startsWith('='))
         return tsText(raw); // an expression, not a value of `wire`
-    if (wire === 'json')
-        return raw; // already JSON — emit it verbatim
+    if (wire === 'json') {
+        // emitted unquoted, so it must be JSON
+        try {
+            JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`decompile: variable ${JSON.stringify(id)} has type "json" but its default ${JSON.stringify(raw)} is not JSON.`);
+        }
+        return raw;
+    }
     if (wire === 'number')
         return Number.isFinite(Number(raw)) ? String(Number(raw)) : tsText(raw);
     // Only the two literals are booleans. Anything else — an empty `default=""`, which

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

@@ -20,8 +20,10 @@
 import type { TypeDesc } from '../core/expr.js';
 import { type ActionSpec, type ConnectorOpts, type EventSubscription, type TriggerOptions } from '../core/actions.js';
 import { type ConnectorDescriptor, type TriggerDescriptor } from '../core/connectors.js';
+import type { CarriedConnectorField } from '../core/carried-connector-fields.js';
+export type { CarriedConnectorField, CarriedFieldLocation } from '../core/carried-connector-fields.js';
 export { preserveCaseJson } from './preserve.js';
-export type { CaseJsonPreservation, PreservedCaseNode, PreservedTaskFields, PreservedVariableLane } from './preserve.js';
+export type { CaseJsonPreservation, PreservedCaseNode, PreservedConnectorConfiguration, PreservedTaskFields, PreservedVariableLane } from './preserve.js';
 export { CaseBuildError } from './case-expr-check.js';
 export type { CaseLocatedDiagnostic } from './case-expr-check.js';
 export type CaseRuleType = 'case-entered' | 'required-tasks-completed' | 'required-stages-completed' | 'selected-stage-completed' | 'selected-stage-exited' | 'selected-tasks-completed' | 'current-stage-entered' | 'adhoc' | 'runs-sequentially' | 'user-selected-stage' | 'wait-for-connector' | 'sla-status-change' | 'api-event';
@@ -424,7 +426,34 @@ export type WaitConnectorSpec = WaitConnectorPlaceholderSpec | EventSubscription
  */
 export type ConnectorSpecData = Extract<ActionSpec, {
     kind: 'connector';
-}>;
+}> & {
+    /** The plan's own declarations of fields the library lacks; see {@link CaseConnectorOpts.carriedFields}. */
+    carriedFields?: readonly CarriedConnectorField[];
+};
+/**
+ * {@link TaskBuilder.connector}'s options: the Flow `connector()` options, plus
+ * the fields a decompiled task carries.
+ */
+export interface CaseConnectorOpts extends ConnectorOpts {
+    /**
+     * Fields the plan this task was decompiled from declares and the connector
+     * library does not. Written by `decompile`; leave it in place, and do not add
+     * to it by hand.
+     *
+     * @remarks
+     * Studio Web saves a connector task against the live connector, which can be
+     * newer than the published library. Decompile copies the saved declaration of
+     * each such field (from the task's `fieldsContainer.inputFields`), so `check`
+     * and `compile` accept the value the plan already has instead of refusing it
+     * as an unknown input (#1362). For instance, an Outlook `get-email-list` task
+     * saved at connector 1.47.0 carries
+     * `[{ name: 'bodyFormat', location: 'query', type: 'string' }]`.
+     *
+     * A carried field only adds a name: an input the library declares is checked
+     * against the library, and a carried field is never required.
+     */
+    carriedFields?: readonly CarriedConnectorField[];
+}
 /**
  * The external agent's or automation's `executionType`, as Integration Service
  * reports it for the connector object.
@@ -1088,22 +1117,22 @@ declare class TaskBuilder {
      *
      * @param descriptor - The generated operation, from a prepared connector module.
      * @param inputs - The activity's inputs, typed by the descriptor.
-     * @param opts - Symbolic `connection` / `folder`, an action `version`, and the
-     * `object` a generic operation addresses.
+     * @param opts - Symbolic `connection` / `folder`, an action `version`, the
+     * `object` a generic operation addresses, and the `carriedFields` decompile writes.
      * @returns This builder, so calls chain.
      */
-    connector<I extends Record<string, unknown>, O>(descriptor: ConnectorDescriptor<I, O>, inputs: I, opts?: ConnectorOpts): this;
+    connector<I extends Record<string, unknown>, O>(descriptor: ConnectorDescriptor<I, O>, inputs: I, opts?: CaseConnectorOpts): this;
     /**
      * Stringly form, for a connector with no prepared module.
      *
      * @param key - The connector library key, e.g. `'uipath-salesforce-slack'`.
      * @param action - The operation id, e.g. `'send-message-to-channel'`.
      * @param inputs - The activity's inputs.
-     * @param opts - Symbolic `connection` / `folder`, an action `version`, and the
-     * `object` a generic operation addresses.
+     * @param opts - Symbolic `connection` / `folder`, an action `version`, the
+     * `object` a generic operation addresses, and the `carriedFields` decompile writes.
      * @returns This builder, so calls chain.
      */
-    connector(key: string, action: string, inputs?: Record<string, unknown>, opts?: ConnectorOpts): this;
+    connector(key: string, action: string, inputs?: Record<string, unknown>, opts?: CaseConnectorOpts): this;
     /**
      * A wait-for-connector task — suspend the stage until an Integration Service
      * **event** fires. A generated descriptor supplies the connector/event identity;

package/dist/case/case-sdk.js

@@ -398,7 +398,12 @@ class TaskBuilder {
         this.setKind('connector');
         // Reuse the shared connector() so descriptor/nodeType splitting + version
         // handling match the Flow surface exactly; store the connector ActionSpec.
-        this._connector = makeConnector(a, b, c, d);
+        const spec = makeConnector(a, b, c, d);
+        // The options are the 4th argument in the stringly form, the 3rd with a descriptor.
+        const carried = (typeof a === 'string' ? d : c)?.carriedFields;
+        if (carried !== undefined)
+            spec.carriedFields = carried;
+        this._connector = spec;
         return this;
     }
     waitForConnector(descriptorOrSpec = {}, opts) {

package/dist/case/connector-saved-config.d.ts

@@ -0,0 +1,64 @@
+/**
+ * A Designer-saved connector task's `optionalConfiguration`, kept through a
+ * decompile -> compile round trip (#1362).
+ *
+ * Studio Web saves a connector task's configuration in two halves:
+ * `essentialConfiguration` (what the runtime needs, which `compile` rebuilds
+ * from the library) and `optionalConfiguration` (the Designer's own state,
+ * including `fieldsContainer.inputFields`, the live connector's field list).
+ * Compile writes the essential half only, so before this a plan lost its saved
+ * field list on its first SDK compile. The next `decompile` then had nothing to
+ * carry `carriedFields` from, and `check` refused a field such as Outlook
+ * `bodyFormat` again on the second edit.
+ *
+ * Decompile now records the saved optional half in `preserveCaseJson`, keyed
+ * by task, and compile writes it back. It is written back only while the task
+ * still calls the same connector operation (connector key, object, method and
+ * path): a task the edit pointed at another operation has no saved state for
+ * that operation, and gets the essential half only, as a new task does.
+ *
+ * Only a half with a `fieldsContainer` is kept. Studio Web renders a task's
+ * fields from that container when the optional half is non-empty, and shows
+ * them empty without it (the essential-only rule in `core/connector-configuration.ts`).
+ *
+ * The half also holds the Designer's display caches (`cachedBrowserItems`,
+ * `cachedLookupValues`, `cachedPropertyMappings`), which describe input VALUES
+ * as they were saved: `cachedBrowserItems` maps `parentFolderId` to the folder
+ * "Inbox" and its id. After an edit that changes the value, that entry would
+ * describe the old folder. So decompile also records each cached field's saved
+ * value, and compile keeps a cache entry only when the field still has that
+ * value. A cache entry not in the `[field, item]` pair form, the only form
+ * measured in Designer plans, cannot be matched to a field and is dropped.
+ */
+/** The connector operation a connector task calls, as its `context` rows name it. */
+export interface ConnectorTaskIdentity {
+    connectorKey: string;
+    objectName: string;
+    method: string;
+    path: string;
+}
+/** The operation an `execute-connector-activity` task calls, or `undefined` for any other task. */
+export declare function connectorTaskIdentity(task: Record<string, any>): ConnectorTaskIdentity | undefined;
+/** Whether two operations are the same one. */
+export declare function sameConnectorOperation(a: ConnectorTaskIdentity, b: ConnectorTaskIdentity): boolean;
+/** The task's saved `optionalConfiguration`, when it is an object with a `fieldsContainer`. */
+export declare function savedOptionalConfiguration(task: Record<string, any>): Record<string, unknown> | undefined;
+/**
+ * Write `optional` into the task's configuration beside its essential half.
+ *
+ * @returns `'written'`, `'same'` when the task already has that exact half,
+ * `'different'` when it has another one, or `'no-configuration'` when the task
+ * has no configuration to write into.
+ */
+export declare function writeOptionalConfiguration(task: Record<string, any>, optional: Record<string, unknown>): 'written' | 'same' | 'different' | 'no-configuration';
+/**
+ * The saved value of every field the half's caches name, as the task sends it.
+ * Decompile records it; compile compares against it (see the module comment).
+ */
+export declare function cachedFieldValues(task: Record<string, any>, optional: Record<string, unknown>): Record<string, unknown>;
+/**
+ * `optional` with each cache entry kept only while its field still has its
+ * saved value in `task`. A cache that is not a list keeps its value; an entry
+ * not in the `[field, item]` form is dropped.
+ */
+export declare function withCurrentCaches(task: Record<string, any>, optional: Record<string, unknown>, saved?: Readonly<Record<string, unknown>>): Record<string, unknown>;

package/dist/case/connector-saved-config.js

@@ -0,0 +1,168 @@
+/**
+ * A Designer-saved connector task's `optionalConfiguration`, kept through a
+ * decompile -> compile round trip (#1362).
+ *
+ * Studio Web saves a connector task's configuration in two halves:
+ * `essentialConfiguration` (what the runtime needs, which `compile` rebuilds
+ * from the library) and `optionalConfiguration` (the Designer's own state,
+ * including `fieldsContainer.inputFields`, the live connector's field list).
+ * Compile writes the essential half only, so before this a plan lost its saved
+ * field list on its first SDK compile. The next `decompile` then had nothing to
+ * carry `carriedFields` from, and `check` refused a field such as Outlook
+ * `bodyFormat` again on the second edit.
+ *
+ * Decompile now records the saved optional half in `preserveCaseJson`, keyed
+ * by task, and compile writes it back. It is written back only while the task
+ * still calls the same connector operation (connector key, object, method and
+ * path): a task the edit pointed at another operation has no saved state for
+ * that operation, and gets the essential half only, as a new task does.
+ *
+ * Only a half with a `fieldsContainer` is kept. Studio Web renders a task's
+ * fields from that container when the optional half is non-empty, and shows
+ * them empty without it (the essential-only rule in `core/connector-configuration.ts`).
+ *
+ * The half also holds the Designer's display caches (`cachedBrowserItems`,
+ * `cachedLookupValues`, `cachedPropertyMappings`), which describe input VALUES
+ * as they were saved: `cachedBrowserItems` maps `parentFolderId` to the folder
+ * "Inbox" and its id. After an edit that changes the value, that entry would
+ * describe the old folder. So decompile also records each cached field's saved
+ * value, and compile keeps a cache entry only when the field still has that
+ * value. A cache entry not in the `[field, item]` pair form, the only form
+ * measured in Designer plans, cannot be matched to a field and is dropped.
+ */
+const JSON_STRING = '=jsonString:';
+const IDENTITY_ROWS = ['connectorKey', 'objectName', 'method', 'path'];
+/** The task's `metadata` context row's body, when it has one. */
+function metadataBody(task) {
+    const rows = task?.data?.context;
+    if (!Array.isArray(rows))
+        return undefined;
+    const body = rows.find((row) => row?.name === 'metadata')?.body;
+    return body && typeof body === 'object' ? body : undefined;
+}
+/** The parsed `=jsonString:` configuration of a connector task, or `undefined`. */
+function parsedConfiguration(task) {
+    const encoded = metadataBody(task)?.activityPropertyConfiguration?.configuration;
+    if (typeof encoded !== 'string' || !encoded.startsWith(JSON_STRING))
+        return undefined;
+    try {
+        const parsed = JSON.parse(encoded.slice(JSON_STRING.length));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The operation an `execute-connector-activity` task calls, or `undefined` for any other task. */
+export function connectorTaskIdentity(task) {
+    if (task?.type !== 'execute-connector-activity' || !Array.isArray(task.data?.context))
+        return undefined;
+    const value = (name) => task.data.context.find((row) => row?.name === name)?.value;
+    const values = IDENTITY_ROWS.map(value);
+    if (values.some((v) => typeof v !== 'string'))
+        return undefined;
+    const [connectorKey, objectName, method, path] = values;
+    return { connectorKey, objectName, method, path };
+}
+/** Whether two operations are the same one. */
+export function sameConnectorOperation(a, b) {
+    return IDENTITY_ROWS.every((name) => a[name] === b[name]);
+}
+/** The task's saved `optionalConfiguration`, when it is an object with a `fieldsContainer`. */
+export function savedOptionalConfiguration(task) {
+    const optional = parsedConfiguration(task)?.optionalConfiguration;
+    if (!optional || typeof optional !== 'object' || Array.isArray(optional))
+        return undefined;
+    const container = optional.fieldsContainer;
+    return container && typeof container === 'object' ? optional : undefined;
+}
+/**
+ * Write `optional` into the task's configuration beside its essential half.
+ *
+ * @returns `'written'`, `'same'` when the task already has that exact half,
+ * `'different'` when it has another one, or `'no-configuration'` when the task
+ * has no configuration to write into.
+ */
+export function writeOptionalConfiguration(task, optional) {
+    const config = parsedConfiguration(task);
+    if (!config)
+        return 'no-configuration';
+    if (config.optionalConfiguration !== undefined)
+        return JSON.stringify(config.optionalConfiguration) === JSON.stringify(optional) ? 'same' : 'different';
+    metadataBody(task).activityPropertyConfiguration.configuration =
+        `${JSON_STRING}${JSON.stringify({ ...config, optionalConfiguration: optional })}`;
+    return 'written';
+}
+/** Whether a configuration key is one of the Designer's value caches (`cachedBrowserItems`, …). */
+function isCacheKey(key) {
+    return /^cached[A-Z]/.test(key);
+}
+/** A cache entry's field, when it is in the `[field, item]` pair form. */
+function cacheEntryField(entry) {
+    return Array.isArray(entry) && entry.length === 2 && typeof entry[0] === 'string' ? entry[0] : undefined;
+}
+function camel(name) {
+    return name.replace(/_([a-z0-9])/gi, (_m, c) => String(c).toUpperCase());
+}
+/** The input container `name` of a task (`pathParameters`, `queryParameters`, `body`). */
+function container(task, name) {
+    const body = Array.isArray(task?.data?.inputs)
+        ? task.data.inputs.find((row) => row?.name === name)?.body : undefined;
+    return body && typeof body === 'object' && !Array.isArray(body) ? body : undefined;
+}
+/**
+ * The wire value a task sends for `field`, or `null` when it sends none: a
+ * query or path parameter (by its name or the camelCased wire name), else a
+ * body field (a dotted name reads the nested body).
+ */
+function fieldValue(task, field) {
+    for (const name of ['queryParameters', 'pathParameters']) {
+        const slot = container(task, name);
+        for (const key of [field, camel(field)])
+            if (slot && Object.prototype.hasOwnProperty.call(slot, key))
+                return slot[key];
+    }
+    let at = container(task, 'body');
+    if (at && Object.prototype.hasOwnProperty.call(at, field))
+        return at[field];
+    for (const part of field.split('.')) {
+        if (!at || typeof at !== 'object' || !Object.prototype.hasOwnProperty.call(at, part))
+            return null;
+        at = at[part];
+    }
+    return at ?? null;
+}
+/**
+ * The saved value of every field the half's caches name, as the task sends it.
+ * Decompile records it; compile compares against it (see the module comment).
+ */
+export function cachedFieldValues(task, optional) {
+    const out = {};
+    for (const [key, cache] of Object.entries(optional)) {
+        if (!isCacheKey(key) || !Array.isArray(cache))
+            continue;
+        for (const entry of cache) {
+            const field = cacheEntryField(entry);
+            if (field !== undefined && !Object.prototype.hasOwnProperty.call(out, field))
+                out[field] = fieldValue(task, field);
+        }
+    }
+    return out;
+}
+/**
+ * `optional` with each cache entry kept only while its field still has its
+ * saved value in `task`. A cache that is not a list keeps its value; an entry
+ * not in the `[field, item]` form is dropped.
+ */
+export function withCurrentCaches(task, optional, saved = {}) {
+    const same = (field) => Object.prototype.hasOwnProperty.call(saved, field)
+        && JSON.stringify(saved[field]) === JSON.stringify(fieldValue(task, field));
+    return Object.fromEntries(Object.entries(optional).map(([key, cache]) => {
+        if (!isCacheKey(key) || !Array.isArray(cache))
+            return [key, cache];
+        return [key, cache.filter((entry) => {
+                const field = cacheEntryField(entry);
+                return field !== undefined && same(field);
+            })];
+    }));
+}

package/dist/case/decompile.d.ts

@@ -4,6 +4,7 @@
  * input bytes; platform-owned preservation lanes are handled separately.
  */
 import type { Library } from '../core/library.js';
+import { type ConnectorTaskIdentity } from './connector-saved-config.js';
 interface IoRow {
     id?: string;
     name?: string;
@@ -217,6 +218,14 @@ type Preservation = {
         task: string;
         fields: Record<string, unknown>;
     }>;
+    connectorConfigurations?: Array<{
+        stage: string;
+        lane: number;
+        task: string;
+        connector: ConnectorTaskIdentity;
+        optionalConfiguration: Record<string, unknown>;
+        cachedFieldValues: Record<string, unknown>;
+    }>;
     triggerDataFields?: Array<Record<string, unknown>>;
     omitStagePositions?: string[];
     omitTaskElementIds?: Array<{

package/dist/case/decompile.js

@@ -1,3 +1,5 @@
+import { savedFieldsMissingFromLibrary, withCarriedFields } from '../core/carried-connector-fields.js';
+import { cachedFieldValues, connectorTaskIdentity, savedOptionalConfiguration } from './connector-saved-config.js';
 import { commentText } from '../core/comment-text.js';
 import { implicitInArgTrigger } from './in-arg-binding.js';
 import { tsLiteral, tsNumber } from '../core/ts-literal.js';
@@ -511,6 +513,21 @@ function selectNextStageByExit(plan, refs) {
                 ['connector', connectorSource],
             ])]]);
 }
+/**
+ * A connector task's parsed `=jsonString:` activity configuration, or
+ * `undefined` when it has none. Malformed JSON is `connectorVersion`'s to refuse.
+ */
+function savedConfiguration(context) {
+    const encoded = context.get('metadata')?.body?.activityPropertyConfiguration?.configuration;
+    if (typeof encoded !== 'string' || !encoded.startsWith('=jsonString:'))
+        return undefined;
+    try {
+        return JSON.parse(encoded.slice('=jsonString:'.length));
+    }
+    catch {
+        return undefined;
+    }
+}
 function connectorVersion(context) {
     const metadata = context.get('metadata')?.body;
     const encoded = metadata?.activityPropertyConfiguration?.configuration;
@@ -555,6 +572,11 @@ function connectorInputs(slots, resolved, owner) {
     const parameterByWireName = new Map();
     for (const parameter of resolved.entry.operation?.parameters ?? [])
         parameterByWireName.set(toCamel(String(parameter.name)), String(parameter.name));
+    // A carried query or path field is a parameter too, which the library's
+    // `operation.parameters` does not list.
+    for (const field of resolved.fields)
+        if ((field.location === 'query' || field.location === 'path') && !parameterByWireName.has(toCamel(field.name)))
+            parameterByWireName.set(toCamel(field.name), field.name);
     const inputs = {};
     const fileParts = new Set(resolved.multipartParts
         ?.filter((part) => part.dataType.toLowerCase() === 'file').map((part) => part.name));
@@ -604,7 +626,13 @@ function connectorCall(task, refs, library) {
         objectName: String(objectName),
         version: connectorVersion(context),
     });
-    const resolved = library.resolve(identity.key, identity.action, identity.version, identity.object);
+    const fromLibrary = library.resolve(identity.key, identity.action, identity.version, identity.object);
+    // The fields the plan's saved field list declares and the library lacks: a
+    // Designer plan saved against a newer connector than the library uses them,
+    // and the source carries their declarations so check and compile accept the
+    // values instead of refusing them as unknown inputs (#1362).
+    const carried = savedFieldsMissingFromLibrary(savedConfiguration(context), fromLibrary);
+    const resolved = withCarriedFields(fromLibrary, carried);
     const inputs = connectorInputs(Array.isArray(data.inputs) ? data.inputs : [], resolved);
     const connection = bindingName(context.get('connection')?.value, refs);
     const folder = bindingName(context.get('folderKey')?.value, refs);
@@ -613,6 +641,7 @@ function connectorCall(task, refs, library) {
         ['folder', folder !== undefined ? tsLiteral(folder) : undefined],
         ['version', identity.version !== '1.0.0' ? tsLiteral(identity.version) : undefined],
         ['object', identity.object !== undefined ? tsLiteral(identity.object) : undefined],
+        ['carriedFields', carried.length ? tsLiteral(carried) : undefined],
     ]);
     return `.connector(${tsLiteral(identity.key)}, ${tsLiteral(identity.action)}, ${tsLiteral(inputs)}${options ? `, ${options}` : ''})`;
 }
@@ -1473,6 +1502,7 @@ export function collectPreservation(plan) {
         'entryConditions', 'conditions', 'nonSequentialRunConditions',
     ]);
     const taskFields = [];
+    const connectorConfigurations = [];
     const omitTaskElementIds = [];
     const omitStagePositions = [];
     for (const stage of (plan.nodes ?? []).filter(isStage)) {
@@ -1494,10 +1524,22 @@ export function collectPreservation(plan) {
                 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 });
+            // The Designer's half of a connector task's configuration, which compile
+            // does not rebuild: its saved field list is what the next decompile
+            // carries `carriedFields` from (#1362).
+            const connector = connectorTaskIdentity(task);
+            const optionalConfiguration = connector && savedOptionalConfiguration(task);
+            if (connector && optionalConfiguration)
+                connectorConfigurations.push({
+                    stage: label, lane: laneIndex, task: task.displayName ?? '', connector, optionalConfiguration,
+                    cachedFieldValues: cachedFieldValues(task, optionalConfiguration),
+                });
         }));
     }
     if (taskFields.length)
         preservation.taskFields = taskFields;
+    if (connectorConfigurations.length)
+        preservation.connectorConfigurations = connectorConfigurations;
     if (omitTaskElementIds.length)
         preservation.omitTaskElementIds = omitTaskElementIds;
     if (omitStagePositions.length)

package/dist/case/preserve.d.ts

@@ -27,6 +27,26 @@ export interface PreservedTaskRef {
     /** Task display name used to find the rebuilt task. */
     task: string;
 }
+/**
+ * A Designer-saved connector task's `optionalConfiguration`, written back while
+ * the task calls the same operation (`case/connector-saved-config.ts`, #1362).
+ */
+export interface PreservedConnectorConfiguration extends PreservedTaskRef {
+    /** The operation the half was saved for: the task's `connectorKey`, `objectName`, `method` and `path`. */
+    connector: {
+        connectorKey: string;
+        objectName: string;
+        method: string;
+        path: string;
+    };
+    /** The saved half, verbatim. It always has a `fieldsContainer`. */
+    optionalConfiguration: Record<string, unknown>;
+    /**
+     * The saved value of each field the half's caches name. Compile keeps a cache
+     * entry only while its field still has this value.
+     */
+    cachedFieldValues?: Record<string, unknown>;
+}
 export interface PreservedTaskFields extends PreservedTaskRef {
     /** Wire-only fields; the preservation contract permits `elementId` only. */
     fields: Record<string, unknown>;
@@ -129,6 +149,8 @@ export interface CaseJsonPreservation {
     variableOrder?: Partial<Record<PreservedVariableLane, string[]>>;
     /** Wire-only task identity fields aligned without authoring them. */
     taskFields?: PreservedTaskFields[];
+    /** Designer-saved connector `optionalConfiguration`s, by task. */
+    connectorConfigurations?: PreservedConnectorConfiguration[];
     /** Platform-owned trigger data fields aligned by trigger order. */
     triggerDataFields?: Array<Record<string, unknown>>;
     /** Stage labels whose source JSON intentionally omitted inline positions. */

package/dist/case/preserve.js

@@ -164,6 +164,20 @@ export function caseJsonPreservationErrors(payload) {
                     errors.push(`preserved binding row "${r.id}" carries no resource key other than its own id`);
             });
     }
+    for (const entry of payload.connectorConfigurations ?? []) {
+        if (!Number.isInteger(entry.lane) || entry.lane < 0)
+            errors.push(`preserved connector configuration lane "${entry.lane}" is not a non-negative integer`);
+        const connector = entry.connector;
+        if (!connector || ['connectorKey', 'objectName', 'method', 'path'].some((name) => typeof connector[name] !== 'string'))
+            errors.push(`preserved connector configuration of task "${entry.task}" must name its connectorKey, objectName, method and path`);
+        const optional = entry.optionalConfiguration;
+        if (!optional || typeof optional !== 'object' || Array.isArray(optional)
+            || !optional.fieldsContainer || typeof optional.fieldsContainer !== 'object')
+            errors.push(`preserved connector configuration of task "${entry.task}" must be an object with a fieldsContainer`);
+        if (entry.cachedFieldValues !== undefined
+            && (!entry.cachedFieldValues || typeof entry.cachedFieldValues !== 'object' || Array.isArray(entry.cachedFieldValues)))
+            errors.push(`preserved connector configuration of task "${entry.task}" has cachedFieldValues that is not an object`);
+    }
     for (const [index, fields] of (payload.triggerDataFields ?? []).entries())
         for (const field of Object.keys(fields))
             if (!PRESERVED_TRIGGER_DATA_KEYS.has(field))

package/dist/case/serialize.js

@@ -13,6 +13,8 @@ import { isUnrestorableSlotId, taskFingerprint } from './preserve.js';
 import { v31TaskSets } from './task-sets.js';
 import { camelizeName, defaultActionOutputVar } from './action-output-var.js';
 import { buildConnectorInputs, nestConnectorBody, replayInputsOf, transportHttpMethod } from '../core/connector-inputs.js';
+import { carriedConnectorFieldsRefusal, withCarriedFields } from '../core/carried-connector-fields.js';
+import { connectorTaskIdentity, sameConnectorOperation, withCurrentCaches, writeOptionalConfiguration } from './connector-saved-config.js';
 import { buildEssentialConfiguration } from '../core/connector-configuration.js';
 import { EQUALS_EXPR_DIALECT } from '../core/connector-checks.js';
 import { bindingLabelRefusal } from '../core/binding-messages.js';
@@ -612,6 +614,20 @@ export function applyPreservation(result, preservation, options = {}) {
             task[field] = value;
         }
     }
+    for (const entry of preservation.connectorConfigurations ?? []) {
+        const stage = stageNodes.find((candidate) => candidate.data?.label === entry.stage);
+        const task = stageTask(stage, entry.task);
+        // A deleted task, or one the edit pointed at another operation, has no use
+        // for the saved half: it gets the essential half only, as a new task does.
+        const now = task && connectorTaskIdentity(task);
+        if (!task || !now || !sameConnectorOperation(now, entry.connector))
+            continue;
+        // The Designer's caches describe input values as saved: an entry whose
+        // field the edit changed would show the old value, so it is dropped.
+        const written = writeOptionalConfiguration(task, withCurrentCaches(task, entry.optionalConfiguration, entry.cachedFieldValues));
+        if (written === 'different' && !options.overwrite)
+            throw new CompileRefusal('PRESERVATION_FIELD_COLLISION', `preserved connector configuration of task "${entry.stage}/${entry.task}" collides with serializer-owned output.`);
+    }
     for (const entry of preservation.omitTaskElementIds ?? []) {
         const stage = stageNodes.find((candidate) => candidate.data?.label === entry.stage);
         const task = stageTask(stage, entry.task);
@@ -796,6 +812,7 @@ export function followRenames(result, preservation) {
             stages,
         },
         ...(preservation.taskFields ? { taskFields: preservation.taskFields.map(ref) } : {}),
+        ...(preservation.connectorConfigurations ? { connectorConfigurations: preservation.connectorConfigurations.map(ref) } : {}),
         ...(preservation.omitTaskElementIds ? { omitTaskElementIds: preservation.omitTaskElementIds.map(ref) } : {}),
         ...(preservation.omitStagePositions ? { omitStagePositions: preservation.omitStagePositions.map(stageName) } : {}),
     };
@@ -1901,7 +1918,13 @@ function connectorTaskData(spec, resolver, elementId, where, executionType, even
     if (!resolver.library)
         throw new CompileRefusal('LIBRARY_REQUIRED', `connector task needs the connector library — pass { library } to serialize or use uip maestro case compile --library.`);
     const library = resolver.library;
-    const rc = onTask(where, () => resolveOperation(library, spec));
+    // A decompiled task's carried fields widen the library's field list with the
+    // plan's own declarations, so a field the Designer saved against a newer
+    // connector than the library compiles instead of being refused (#1362).
+    const carriedRefusal = carriedConnectorFieldsRefusal(spec.carriedFields, where);
+    if (carriedRefusal)
+        throw new CompileRefusal('CARRIED_DEFINITION_INVALID', carriedRefusal);
+    const rc = withCarriedFields(onTask(where, () => resolveOperation(library, spec)), spec.carriedFields);
     const op = rc.entry.operation ?? {};
     const context = [
         io('connectorKey', 'string', { value: rc.connectorKey }),