@uipath/maestro-builder-sdk 6.33.2 → 6.34.0

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

@@ -372,7 +372,7 @@ export interface BuiltCaseExitCondition {
     marksCaseComplete?: boolean;
     rules: CaseRule[][];
 }
-export type TaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management' | 'flow-process' | 'external-agent' | 'external-workflow' | 'action' | 'connector' | 'wait-for-timer' | 'wait-for-connector';
+export type TaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management' | 'flow-process' | 'business-rule' | 'external-agent' | 'external-workflow' | 'action' | 'connector' | 'wait-for-timer' | 'wait-for-connector';
 /** Published-resource task kinds that the Case schema permits as unresolved skeletons. */
 export type UnresolvedReferenceTaskKind = 'process' | 'agent' | 'rpa' | 'api-workflow' | 'case-management';
 /**
@@ -428,6 +428,25 @@ export interface TaskRef {
     name: string;
     folderPath: string;
 }
+/**
+ * Options for {@link TaskBuilder.businessRule}.
+ */
+export interface BusinessRuleOptions {
+    /** The Orchestrator folder the rule is deployed in, e.g. `Shared`. */
+    folder: string;
+    /**
+     * The rule's whole result schema, as `uip maestro case tasks describe --type
+     * business-rule` returns it on the `output` row (`_jsonSchema`): one object
+     * keyed by decision name, each holding that decision's columns. Optional; it
+     * is copied onto the `output` row so the designer can show the columns.
+     */
+    resultSchema?: unknown;
+}
+/** Normalized business-rule configuration stored on a built task. */
+export interface BusinessRuleSpecData {
+    /** The rule's decision-keyed result schema, when the author supplied it. */
+    resultSchema?: unknown;
+}
 /**
  * Action-task recipient type. `2` = a single user by email — the only value the
  * platform corpus exercises for case action tasks; `0`/`1`/`3` are reserved for
@@ -520,6 +539,8 @@ export interface BuiltTask {
     name: string;
     kind: TaskKind;
     ref?: TaskRef;
+    /** business-rule task: the rule's decision-keyed result schema, when known. */
+    businessRule?: BusinessRuleSpecData;
     action?: ActionSpecData;
     connector?: ConnectorSpecData;
     /** Descriptor-resolved external agent/workflow configuration. */
@@ -718,6 +739,7 @@ declare class TaskBuilder {
     private readonly _name;
     private _kind?;
     private _ref?;
+    private _businessRule?;
     private _action?;
     private _connector?;
     private _external?;
@@ -808,6 +830,35 @@ declare class TaskBuilder {
     flowProcess(name: string, opts?: {
         folder?: string;
     }): this;
+    /**
+     * Evaluate a deployed **business rule** (a DMN decision package) and read its
+     * decisions back.
+     *
+     * @remarks
+     * Emits a `business-rule` task at `version: 'v3'` (below v3 the engine cannot
+     * run the `.uirule` package a BusinessRules project deploys). The rule is named
+     * through a `name` + `folderPath` pair of root bindings with
+     * `resource: 'BusinessRule'` and `resourceKey: '<folder>.<name>'`, the shape
+     * Studio Web and `uip maestro case bindings sync` write.
+     *
+     * The task always carries the two outputs every business-rule task has: `output`
+     * (`source: '=result'`, the whole decision-keyed result) and `Error`. To store
+     * one decision column in a case variable, add an extract with `.outputs()`
+     * whose source names the decision and column directly — `=<Decision>.<column>`,
+     * never `=result.…` or `=output.…`:
+     *
+     * ```ts
+     * .task('Score Credit Risk', t => t
+     *   .businessRule('CreditRisk', { folder: 'Shared' })
+     *   .inputs({ creditScore: { value: '=vars.creditScore', type: 'number' } })
+     *   .outputs({ riskBand: { source: '=RiskDecision.riskBand', type: 'string' } }))
+     * ```
+     *
+     * @param name - The deployed rule's name.
+     * @param opts - `folder` (required) and the optional `resultSchema`.
+     * @returns This builder, so calls chain.
+     */
+    businessRule(name: string, opts: BusinessRuleOptions): this;
     private external;
     /**
      * Invoke an external agent through its generated Integration Service descriptor.

package/dist/case/case-sdk.js

@@ -160,6 +160,7 @@ class TaskBuilder {
     _name;
     _kind;
     _ref;
+    _businessRule;
     _action;
     _connector;
     _external;
@@ -263,6 +264,39 @@ class TaskBuilder {
     flowProcess(name, opts) {
         return this.reference('flow-process', name, opts);
     }
+    /**
+     * Evaluate a deployed **business rule** (a DMN decision package) and read its
+     * decisions back.
+     *
+     * @remarks
+     * Emits a `business-rule` task at `version: 'v3'` (below v3 the engine cannot
+     * run the `.uirule` package a BusinessRules project deploys). The rule is named
+     * through a `name` + `folderPath` pair of root bindings with
+     * `resource: 'BusinessRule'` and `resourceKey: '<folder>.<name>'`, the shape
+     * Studio Web and `uip maestro case bindings sync` write.
+     *
+     * The task always carries the two outputs every business-rule task has: `output`
+     * (`source: '=result'`, the whole decision-keyed result) and `Error`. To store
+     * one decision column in a case variable, add an extract with `.outputs()`
+     * whose source names the decision and column directly — `=<Decision>.<column>`,
+     * never `=result.…` or `=output.…`:
+     *
+     * ```ts
+     * .task('Score Credit Risk', t => t
+     *   .businessRule('CreditRisk', { folder: 'Shared' })
+     *   .inputs({ creditScore: { value: '=vars.creditScore', type: 'number' } })
+     *   .outputs({ riskBand: { source: '=RiskDecision.riskBand', type: 'string' } }))
+     * ```
+     *
+     * @param name - The deployed rule's name.
+     * @param opts - `folder` (required) and the optional `resultSchema`.
+     * @returns This builder, so calls chain.
+     */
+    businessRule(name, opts) {
+        this.reference('business-rule', name, { folder: opts.folder });
+        this._businessRule = opts.resultSchema === undefined ? {} : { resultSchema: opts.resultSchema };
+        return this;
+    }
     external(kind, descriptor, opts) {
         this.setKind(kind);
         this._external = {
@@ -448,15 +482,16 @@ class TaskBuilder {
         // Task I/O binding is reference-mode only — process/agent/rpa/api-workflow,
         // case-management, and flow-process. Connector tasks derive their own
         // inputs/outputs from the operation schema.
-        const REF_IO = new Set(['process', 'agent', 'rpa', 'api-workflow', 'case-management', 'flow-process']);
+        const REF_IO = new Set(['process', 'agent', 'rpa', 'api-workflow', 'case-management', 'flow-process', 'business-rule']);
         if ((this._inputs || this._outputs) && !REF_IO.has(this._kind))
-            throw new Error(`task "${this._name}": .inputs()/.outputs() are only supported on reference-mode tasks (process/agent/rpa/api-workflow/case-management/flow-process), not "${this._kind}".`);
+            throw new Error(`task "${this._name}": .inputs()/.outputs() are only supported on reference-mode tasks (process/agent/rpa/api-workflow/case-management/flow-process/business-rule), not "${this._kind}".`);
         if (!this._ref && (this._inputs || this._outputs))
             throw new Error(`task "${this._name}": an unresolved reference task cannot declare inputs or outputs.`);
         return {
             name: this._name,
             kind: this._kind,
             ref: this._ref,
+            businessRule: this._businessRule,
             action: this._action,
             connector: this._connector,
             external: this._external,

package/dist/case/check.js

@@ -483,6 +483,36 @@ function checkStage(stage, diags, refStage, refPlacement) {
                 message: `Task "${t.name}" binding "${'var' in invalidBinding ? invalidBinding.var : invalidBinding.name}" has unsupported type ${JSON.stringify(invalidBinding.type)}. Use a type name such as "string" or "jsonSchema"; jsonSchema(...) is only for declaring a structured case variable.`,
                 where: t.name,
             });
+        if (t.kind === 'business-rule') {
+            if (!t.ref || !t.ref.name.trim() || !t.ref.folderPath.trim())
+                diags.push({
+                    level: 'error',
+                    code: 'BUSINESS_RULE_EMPTY_DATA',
+                    message: `Business-rule task "${t.name}" must name its deployed rule and the Orchestrator folder it is deployed in: .businessRule('<rule>', { folder: '<folder>' }).`,
+                    where: t.name,
+                });
+            for (const o of t.outputs ?? []) {
+                const wrapped = /^=\s*(result|output)\./.exec(o.source);
+                if (wrapped)
+                    diags.push({
+                        level: 'error',
+                        code: 'BUSINESS_RULE_OUTPUT_SOURCE',
+                        message: `Business-rule task "${t.name}" output "${o.var}" reads "${o.source}". An extract reads a field of the rule's result directly — write "=${o.source.replace(/^=\s*(result|output)\./, '')}" (\`=<Decision>.<column>\`). The whole result is already the task's own \`output\` row (\`=result\`); \`=${wrapped[1]}.…\` names a field the result does not have.`,
+                        where: t.name,
+                    });
+                // An extract row is NAMED after its source's last segment (`emitTaskOutput`),
+                // so `=Decision.output` writes a second row named `output` beside the
+                // task's own. The case variable it stores into collides with nothing.
+                const rowName = o.source.replace(/^=/, '').split('.').pop();
+                if (rowName === 'output' || rowName === 'Error')
+                    diags.push({
+                        level: 'error',
+                        code: 'BUSINESS_RULE_OUTPUT_NAME',
+                        message: `Business-rule task "${t.name}" output "${o.var}" reads "${o.source}", which writes an output row named "${rowName}" — the name of the task's own ${rowName === 'output' ? '`output` row (the whole result, `=result`)' : '`Error` row (`=Error`)'}. Two rows with one name are ambiguous to the designer; rename the decision column.`,
+                        where: t.name,
+                    });
+            }
+        }
         if (t.kind === 'flow-process' && (!t.ref || !t.ref.name.trim()))
             diags.push({
                 level: 'error',

package/dist/case/compile-cli.js

@@ -364,7 +364,12 @@ function syncBindingsV2(caseplan, outPath) {
             resource: group.resource,
             key: group.key,
             value: group.value,
-            metadata: group.subType ? { subType: group.subType } : {},
+            // A BusinessRule entry carries the bindings version deploy needs to
+            // override its folder — the metadata `uip maestro case bindings sync`
+            // writes for it (no subType).
+            metadata: group.subType
+                ? { subType: group.subType }
+                : group.resource === 'BusinessRule' ? { BindingsVersion: '2.2' } : {},
         });
     }
     resources.push(...connectionResources);

package/dist/case/decompile.js

@@ -579,6 +579,8 @@ function emitTaskKind(task, refs, library) {
         const folder = folderPath ? `, ${opts([['folder', tsLiteral(folderPath)]])}` : '';
         return `.${method}(${tsLiteral(name ?? '')}${folder})`;
     }
+    if (isAuthorableBusinessRule(task))
+        return businessRuleCall(task, refs);
     if (kind === 'action') {
         let recipient;
         if (data.recipient) {
@@ -616,7 +618,12 @@ function emitTaskKind(task, refs, library) {
         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 ?? '?'}".`;
+    const message = kind === 'business-rule'
+        // The converter reads a missing version as v2, whose result shape differs
+        // from v3's decision-keyed one; recompiling it as v3 would change what its
+        // extracts read. Keep the task as data instead.
+        ? `business-rule task "${task.displayName ?? task.id ?? '?'}" has ${data.version === undefined ? 'no version (the converter reads it as v2)' : `version "${String(data.version)}"`}; only v3 business-rule tasks are authorable.`
+        : `unsupported task kind "${kind}" for task "${task.displayName ?? task.id ?? '?'}".`;
     diagnose(refs, {
         code: 'UNSUPPORTED_TASK_KIND',
         message,
@@ -624,6 +631,29 @@ function emitTaskKind(task, refs, library) {
     });
     return `.__UNRESOLVED_TASK_KIND__(${tsLiteral(kind)}, ${tsLiteral(data)})`;
 }
+/** A business-rule task `.businessRule()` can rebuild: v3 only. */
+function isAuthorableBusinessRule(task) {
+    return task.type === 'business-rule' && task.data?.version === 'v3';
+}
+/** The two outputs every business-rule task carries, which `.businessRule()` re-emits itself. */
+function isBusinessRuleOwnOutput(row) {
+    return (row.name === 'output' && row.source === '=result') || (row.name === 'Error' && row.source === '=Error');
+}
+function businessRuleCall(task, refs) {
+    const data = task.data ?? {};
+    const owner = `business-rule task "${task.displayName ?? task.id ?? '?'}"`;
+    const name = bindingDefault(data.name, refs);
+    const folderPath = bindingDefault(data.folderPath, refs);
+    if (typeof name !== 'string' || !name || typeof folderPath !== 'string')
+        throw new Error(`${owner} must name its rule and folder (data.name / data.folderPath).`);
+    const outputRow = (Array.isArray(data.outputs) ? data.outputs : [])
+        .find((row) => row.name === 'output' && row.source === '=result');
+    const resultSchema = outputRow?._jsonSchema;
+    return `.businessRule(${tsLiteral(name)}, ${opts([
+        ['folder', tsLiteral(folderPath)],
+        ['resultSchema', resultSchema !== undefined ? tsLiteral(resultSchema) : undefined],
+    ])})`;
+}
 function ioArg(rows, kind) {
     const valueField = kind === 'inputs' ? 'value' : 'source';
     const entries = rows.map((row) => {
@@ -647,6 +677,14 @@ function emitTask(out, depth, task, lane, refs, library) {
         if (Array.isArray(data.outputs) && data.outputs.length)
             out.line(inner, `.outputs(${ioArg(data.outputs, 'outputs')})`);
     }
+    if (isAuthorableBusinessRule(task)) {
+        const data = task.data ?? {};
+        const extracts = (Array.isArray(data.outputs) ? data.outputs : []).filter((row) => !isBusinessRuleOwnOutput(row));
+        if (Array.isArray(data.inputs) && data.inputs.length)
+            out.line(inner, `.inputs(${ioArg(data.inputs, 'inputs')})`);
+        if (extracts.length)
+            out.line(inner, `.outputs(${ioArg(extracts, 'outputs')})`);
+    }
     if (task.isRequired !== undefined)
         out.line(inner, task.isRequired ? '.required()' : '.required(false)');
     if (task.shouldRunOnlyOnce !== undefined)
@@ -749,11 +787,20 @@ function producedVariableNames(plan) {
         if (!isStage(node))
             continue;
         for (const lane of node.data?.tasks ?? [])
-            for (const task of lane)
-                if (ownEntry(TASK_KIND_METHOD, task.type))
+            for (const task of lane) {
+                if (ownEntry(TASK_KIND_METHOD, task.type)) {
                     for (const row of task.data?.outputs ?? [])
                         if (row.var)
                             produced.add(row.var);
+                }
+                else if (isAuthorableBusinessRule(task)) {
+                    // A business-rule extract registers its case variable on recompile, as
+                    // a reference-task output does; the task's own rows do not.
+                    for (const row of task.data?.outputs ?? [])
+                        if (row.var && !isBusinessRuleOwnOutput(row))
+                            produced.add(row.var);
+                }
+            }
     }
     return produced;
 }

package/dist/case/format-profile.d.ts

@@ -40,7 +40,7 @@ export declare const CASE_FORMAT_PROFILE: Readonly<CaseFormatProfile>;
  * Which Case JSON schema versions `.schemaVersion()` may declare.
  *
  * ONE, and that is the honest answer rather than a placeholder. Case is a
- * closed, whole-document schema: `@uipath/case-schema` ships a chain of 31
+ * closed, whole-document schema: `@uipath/case-schema` ships a chain of
  * grammars (`case-schema-census.json`'s `versionChain`), each with its own
  * forward migration, and a version is a claim that the entire document matches
  * that grammar. This SDK emits the V30 grammar natively — the V30 rule schemas

package/dist/case/format-profile.js

@@ -28,16 +28,20 @@ export const CASE_FORMAT_PROFILE = {
         { featureFlag: 'canvas-useExplicitEntryExitConditions', fromVersion: '12.0.0' },
         { featureFlag: 'canvas-caseUnifiedSchema', fromVersion: '20.0.0' },
     ],
+    // The validation pin (the `@uipath/case-schema` devDependency in
+    // typescript/package.json; the census records it as `generatedFrom.version`)
+    // and the newest Case JSON version that package reads. The writer stays at V30 (`writeVersion`): V31+ is read
+    // and migrated by the platform, not emitted here.
     validationCeiling: {
-        caseSchemaVersion: '0.1016.2',
-        formatVersion: '30.0.0',
+        caseSchemaVersion: '0.1173.0',
+        formatVersion: '32.0.4',
     },
 };
 /**
  * Which Case JSON schema versions `.schemaVersion()` may declare.
  *
  * ONE, and that is the honest answer rather than a placeholder. Case is a
- * closed, whole-document schema: `@uipath/case-schema` ships a chain of 31
+ * closed, whole-document schema: `@uipath/case-schema` ships a chain of
  * grammars (`case-schema-census.json`'s `versionChain`), each with its own
  * forward migration, and a version is a claim that the entire document matches
  * that grammar. This SDK emits the V30 grammar natively — the V30 rule schemas

package/dist/case/serialize.js

@@ -491,8 +491,18 @@ function applyPreservedIdentities(result, preservation) {
             take(task, taskIdentity.id);
             takeConditions(task?.entryConditions, taskIdentity.entryConditions);
             (taskIdentity.inputs ?? []).forEach((row, index) => take(task?.data?.inputs?.[index], row.id));
-            (taskIdentity.outputs ?? []).forEach((row, index) => {
-                const target = task?.data?.outputs?.[index];
+            const outputRows = task?.data?.outputs ?? [];
+            const wantedRows = taskIdentity.outputs ?? [];
+            // Match by name when unique on both sides, else by position.
+            const unique = (names, name) => names.filter((n) => n === name).length === 1;
+            const currentNames = outputRows.map((r) => r?.name);
+            const wantedNames = wantedRows.map((r) => r.name);
+            const named = new Set(wantedRows.filter((r) => unique(wantedNames, r.name) && unique(currentNames, r.name)).map((r) => r.name));
+            wantedRows.forEach((row, index) => {
+                const target = named.has(row.name)
+                    ? outputRows.find((r) => r?.name === row.name)
+                    // A positional match never takes a row a name match owns.
+                    : named.has(outputRows[index]?.name) ? undefined : outputRows[index];
                 const currentId = target?.id;
                 take(target, row.id);
                 if (typeof currentId === 'string' && typeof row.id === 'string' && target?.value === currentId) {
@@ -839,6 +849,8 @@ function taskData(task, resolver, taskId, stageId, ids) {
                 data.outputs = task.outputs.map((o, i) => emitTaskOutput(o, elementId, ids, `${elementId}:out:${i}:${o.var}`, resolver));
             return data;
         }
+        case 'business-rule':
+            return businessRuleTaskData(task, resolver, `${stageId}-${taskId}`, ids);
         case 'action': {
             const a = task.action ?? {};
             const data = {};
@@ -1094,6 +1106,76 @@ function emitTaskOutput(o, elementId, ids, seed, resolver) {
         elementId,
     };
 }
+// ─── Business-rule task ───────────────────────────────────────────────────────
+/** The version a business-rule task carries: below v3 the engine cannot run the
+ * `.uirule` package a BusinessRules project deploys (the case converter falls
+ * back to v2 when the field is missing). Same constant as the CLI's
+ * `BUSINESS_RULE_TASK_VERSION`. */
+const BUSINESS_RULE_TASK_VERSION = 'v3';
+/** The binding `resource` a business rule is bound by — the CLI's and Studio
+ * Web's spelling. `businessRule` (the registry cache category / BPMN binding
+ * pattern) is a different namespace, and a binding that uses it is not a
+ * BusinessRule resource to the bindings_v2 reader. */
+const BUSINESS_RULE_RESOURCE = 'BusinessRule';
+/** Mint (once per resourceKey + attribute) one root `BusinessRule` binding. */
+function businessRuleBinding(resolver, ids, resourceKey, propertyAttribute, value) {
+    for (const entry of resolver.bindingSink.values()) {
+        if (entry.resource === BUSINESS_RULE_RESOURCE && entry.resourceKey === resourceKey
+            && entry.propertyAttribute === propertyAttribute)
+            return entry.id;
+    }
+    const id = ids.make('b', 8, `binding:${BUSINESS_RULE_RESOURCE}:${resourceKey}:${propertyAttribute}`);
+    resolver.bindingSink.set(id, {
+        id,
+        name: propertyAttribute,
+        type: 'string',
+        resource: BUSINESS_RULE_RESOURCE,
+        resourceKey,
+        default: value,
+        propertyAttribute,
+    });
+    return id;
+}
+/**
+ * The `data` of a `business-rule` task, as Studio Web writes it and as the
+ * CLI's `tasks describe --type business-rule` + splice produce it:
+ *
+ * - `name` / `folderPath` are `=bindings.<id>` references to a `BusinessRule`
+ *   binding pair keyed `<folder>.<name>` (the runtime resolves the rule through
+ *   them; `validate --strict` refuses literals);
+ * - `version: 'v3'`;
+ * - `outputs` always starts with `output` (`source: '=result'`, the whole
+ *   decision-keyed result) and `Error` (`source: '=Error'`), followed by the
+ *   author's extract rows, whose sources read a field of the result
+ *   (`=<Decision>.<column>`).
+ */
+function businessRuleTaskData(task, resolver, elementId, ids) {
+    const ref = task.ref;
+    const resourceKey = `${ref.folderPath}.${ref.name}`;
+    const nameId = businessRuleBinding(resolver, ids, resourceKey, 'name', ref.name);
+    const folderId = businessRuleBinding(resolver, ids, resourceKey, 'folderPath', ref.folderPath);
+    const ownRow = (name, source, seed, extra = {}) => {
+        const slot = ids.make('v', 8, `${elementId}:${seed}`);
+        return { name, type: 'jsonSchema', id: slot, var: slot, value: slot, source, target: `=${slot}`, elementId, ...extra };
+    };
+    const resultSchema = task.businessRule?.resultSchema;
+    const outputs = [
+        ownRow('output', '=result', 'br:output', resultSchema === undefined ? {} : { _jsonSchema: resultSchema }),
+        // The CLI's `buildErrorOutput()` row after `addVarIdsToInputsOutputs`:
+        // `displayName`, and the error schema as both `_jsonSchema` and `body`.
+        ownRow('Error', '=Error', 'br:error', {
+            displayName: 'Error', _jsonSchema: structuredClone(ERROR_OUTPUT_SCHEMA), body: structuredClone(ERROR_OUTPUT_SCHEMA),
+        }),
+        ...(task.outputs ?? []).map((o, i) => emitTaskOutput(o, elementId, ids, `${elementId}:out:${i}:${o.var}`, resolver)),
+    ];
+    return {
+        name: `=bindings.${nameId}`,
+        folderPath: `=bindings.${folderId}`,
+        version: BUSINESS_RULE_TASK_VERSION,
+        inputs: (task.inputs ?? []).map((inp, i) => emitTaskInput(inp, elementId, ids, `${elementId}:in:${i}:${inp.name}`)),
+        outputs,
+    };
+}
 // ─── Connector task (execute-connector-activity) ──────────────────────────────
 /**
  * Build the `execute-connector-activity` `data` payload for an IS connector task,
@@ -1353,6 +1435,14 @@ function connectorOutputVar(resolver, base) {
     resolver.connectorOutputCounts.set(base, occurrence);
     return occurrence === 1 ? base : `${base}${occurrence}`;
 }
+/** The `Error` output's schema: the designer's (and the CLI's) `ERROR_OUTPUT_SCHEMA`. */
+const ERROR_OUTPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        code: { type: 'string' }, message: { type: 'string' }, detail: { type: 'string' },
+        category: { type: 'string' }, status: { type: 'number' }, element: { type: 'string' },
+    },
+};
 function connectorOutputs(rc, elementId, resolver) {
     const responseSchema = rc.entry.outputSchema
         ? schemaFromFields(rc.entry.outputSchema.fields ?? [])
@@ -1367,13 +1457,7 @@ function connectorOutputs(rc, elementId, resolver) {
         },
         {
             name: 'Error', displayName: 'Error', type: 'jsonSchema', source: '=Error',
-            body: {
-                type: 'object',
-                properties: {
-                    code: { type: 'string' }, message: { type: 'string' }, detail: { type: 'string' },
-                    category: { type: 'string' }, status: { type: 'number' }, element: { type: 'string' },
-                },
-            },
+            body: structuredClone(ERROR_OUTPUT_SCHEMA),
             var: errorVar, id: errorVar, value: errorVar, target: `=${errorVar}`, elementId,
         },
     ];

package/dist/schema-version.js

@@ -106,11 +106,16 @@ export function schemaVersionRefusal(policy, requested) {
     if (isWritableSchemaVersion(policy, requested))
         return undefined;
     const writable = writableSchemaVersions(policy);
+    const newestWritable = writable.at(-1);
     const direction = policy.latestKnown !== undefined && schemaVersionAtLeast(requested, policy.latestKnown)
         ? compareSchemaVersions(requested, policy.latestKnown) > 0
             ? `The platform's newest known ${family} schema version is ${policy.latestKnown}, so ${requested} is newer than anything this SDK has read.`
             : `${requested} is the platform's current ${family} schema version, but this SDK build has not been taught to write it.`
-        : `${requested} is older than the ${writable.length === 1 ? 'one version' : 'versions'} this build writes.`;
+        : newestWritable !== undefined && compareSchemaVersions(requested, newestWritable) > 0
+            ? `${requested} is a platform ${family} schema version newer than this build writes`
+                + (policy.latestKnown !== undefined ? ` (the platform's current is ${policy.latestKnown})` : '')
+                + '; this SDK build has not been taught to write it.'
+            : `${requested} is older than the ${writable.length === 1 ? 'one version' : 'versions'} this build writes.`;
     return (`${method}("${requested}"): this SDK build writes ${family} schema ${writable.join(' / ')}. ${direction} `
         + `A document's version claims that the WHOLE document matches that schema, so declaring one this build cannot emit `
         + `would write a false claim rather than a different document. ${policy.migration}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.33.2",
+  "version": "6.34.0",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -93,5 +93,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "04124f15f4e70827cb18bbd0f52c0bf676ceedd1"
+  "gitref": "aa9dc9a7c6f6adc8edbf4c20d0681307073bb53b"
 }