@uipath/maestro-builder-sdk 6.69.1 → 6.70.1

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/cli-library.js

@@ -5,7 +5,7 @@
  * the library does not carry passed `check` and failed at `compile` (#1014).
  * Flow and BPMN read their connector facts from `connectorCheckOpts`
  * (`core/cli-library.ts`); Case now does too, through this one builder, which
- * both `case check` and `case compile`'s check pass call.
+ * `case check` calls.
  */
 import { connectorCheckOpts } from '../core/cli-library.js';
 /**

package/dist/case/compile-cli.js

@@ -5,22 +5,24 @@
  * Usage:
  *   node --experimental-strip-types compile-cli.js <case.ts | BaseName> [-o out.json]
  *
- * Runs the fast static check first; if it passes, serializes to a V32
- * caseplan.json. The authoritative deploy gate is `uip maestro case validate`.
+ * Only serializes, to a V32 caseplan.json (docs/CHECK_COMPILE_CONTRACT_DESIGN.md
+ * D1, phase 8). It does not run `check()`'s lint rules: run `case check` first
+ * for those. It stops only when it cannot write a correct plan, a refusal the
+ * serializer throws, printed in `check`'s `✗ [CODE]` shape (and `case check`
+ * reports the same refusal, from the same code). The authoritative deploy gate
+ * is `uip maestro case validate`.
  * Output defaults to the plan file the project in the working directory ships
  * (`caseplan.case` for a project `uip maestro case init` scaffolded), else
  * `caseplan.json`. An `-o` that names a different plan file than the project
  * ships is refused (CASE_OUTPUT_NOT_SHIPPED), and so is a plan file written into
  * a solution directory above its Case project (CASE_OUTPUT_OUTSIDE_PROJECT).
  */
-import { reportDiagnostics, reportResult, thrownDiagnostic } from '../cli-result.js';
+import { diagnosticLine, reportDiagnostics, reportResult, thrownDiagnostic } from '../cli-result.js';
 import { writeJsonFile } from '../core/json-file.js';
 import { readFileSync, existsSync, readdirSync } from 'node:fs';
 import { join, dirname, basename, resolve } from 'node:path';
 import { resolveCaseFile, loadBuiltCase } from './load.js';
 import { serialize } from './serialize.js';
-import { check } from './check.js';
-import { caseCheckOpts } from './cli-library.js';
 import { entryPointIO } from './entry-points.js';
 import { Bindings } from '../core/bindings.js';
 import { offlineBindingLabel } from './ids.js';
@@ -32,6 +34,7 @@ import { CASE_FORMAT_PROFILE } from './format-profile.js';
 import { deriveCaseBindingsV2 } from './bindings-v2.js';
 import { BINDINGS_V2_DOCUMENT_VERSION } from '../core/bindings-v2-resource.js';
 import { sha256Uuid } from '../core/stable-id.js';
+import { CompileRefusal } from '../core/compile-refusal.js';
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
         console.error('usage: compile <case.ts | BaseName> [-o <project>/caseplan.case]');
@@ -53,23 +56,13 @@ export async function run(argv) {
     // fine right after a pull on Flow failed here for no visible reason. The helper
     // also auto-detects the `connectors-local/` overlay `registry prepare` writes,
     // which is what the three copies of these lines used to each decide for itself.
-    // Opened BEFORE the check pass, which reads the same library (#1014).
+    // `case check` opens it the same way (#1014).
     const library = openCliLibrary(argv);
     const { out, bindings } = caseCompileTarget(argv);
-    const diags = check(built, caseCheckOpts(library, bindings));
-    for (const d of diags)
-        console.error(`  ${d.level === 'error' ? '✗' : '⚠'} [${d.code}] ${d.message}`);
-    // Reported before serialize, so every exit path carries what stderr printed.
-    reportDiagnostics(diags);
-    const errors = diags.filter((d) => d.level === 'error');
-    if (errors.length) {
-        console.error(`compile: ${errors.length} error(s); not emitting.`);
-        return 1;
-    }
     const shadow = shadowedOutputDiagnostic(out);
     if (shadow) {
         console.error(`  ✗ [${shadow.code}] ${shadow.message} Fix: ${shadow.suggestion}.`);
-        reportDiagnostics([...diags, shadow]);
+        reportDiagnostics([shadow]);
         console.error('compile: 1 error(s); not emitting.');
         return 1;
     }
@@ -78,9 +71,28 @@ export async function run(argv) {
         caseplan = serialize(built, { library, bindings });
     }
     catch (error) {
-        reportDiagnostics([...diags, thrownDiagnostic(error)]);
-        throw error;
+        if (!(error instanceof Error) || (!(error instanceof CompileRefusal) && error.message.startsWith('internal SDK error:'))) {
+            // A broken SDK invariant still ends the run through the caller (exit 1,
+            // `--json` `error`); the diagnostic is reported first.
+            reportDiagnostics([thrownDiagnostic(error)]);
+            throw error;
+        }
+        // The serializer cannot write a correct plan: a coded refusal, or a throw
+        // it has no refusal for (a `TypeError` on a malformed spec), which is
+        // COMPILE_FAILED, as `case check` reports it (`refusalOf`, serialize.ts).
+        const refused = error instanceof CompileRefusal
+            ? {
+                level: 'error', code: error.code, message: error.message,
+                ...(error.suggestion !== undefined ? { suggestion: error.suggestion } : {}),
+            }
+            : { level: 'error', code: 'COMPILE_FAILED', message: error.message };
+        console.error(`  ${diagnosticLine(refused)}`);
+        reportDiagnostics([refused]);
+        console.error('compile: 1 error(s); not emitting.');
+        return 1;
     }
+    // Reported before the first write, so a write that throws still carries it.
+    reportDiagnostics([]);
     // Entry points first: each trigger carries its entry point's `uniqueId` as
     // `data.inputs.entryPointId`, so the plan is written after the ids are known.
     const triggers = syncEntryPoints(caseplan, out);

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))