@uipath/maestro-builder-sdk 6.69.0 → 6.70.0

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/core/refusals.d.ts

@@ -209,6 +209,7 @@ export declare const REFUSALS: {
     readonly DATAFABRIC_SYSTEM_COLUMN: "lint";
     readonly DEAD_END: "lint";
     readonly DECLARATION_SHAPE: "lowering";
+    readonly DECLARATION_TYPE_NOT_FLOW: "lowering";
     readonly DECLARATION_TYPE_UNKNOWN: "lowering";
     readonly DECOMPILE_NOT_A_NUMBER: "lowering";
     readonly DECOMPILE_VARIABLES_SHAPE: "lowering";

package/dist/core/refusals.js

@@ -21,10 +21,10 @@
  * they get different codes, so one code never both stops compile and lets it
  * write.
  *
- * Since `compile` no longer runs `check` (#1497), a `lint` code is only right
+ * Since `compile` no longer runs `check` (Flow #1497, Case #1446), a `lint` code is only right
  * when the serializer still writes what the source says while the rule fires:
- * otherwise `compile` writes a wrong `.flow` without a word, and the code is
- * `lowering` (the serializer must refuse it). Every Flow `lint` code has a row
+ * otherwise `compile` writes a wrong `.flow` (or caseplan) without a word, and the code is
+ * `lowering` (the serializer must refuse it). Every Flow, Case and BPMN `lint` code has a row
  * in `tests/lint-lossless/` (#1518): a round-trip fixture, a fixture the
  * serializer refuses, or a written reason. The round trip shows the rule's
  * condition survives compile -> decompile -> compile and that compile is
@@ -261,6 +261,7 @@ export const REFUSALS = {
     DATAFABRIC_SYSTEM_COLUMN: 'lint',
     DEAD_END: 'lint',
     DECLARATION_SHAPE: 'lowering',
+    DECLARATION_TYPE_NOT_FLOW: 'lowering',
     DECLARATION_TYPE_UNKNOWN: 'lowering',
     DECOMPILE_NOT_A_NUMBER: 'lowering',
     DECOMPILE_VARIABLES_SHAPE: 'lowering',

package/dist/decompile.js

@@ -39,6 +39,7 @@ import { tsKey as key, tsLiteral, tsNumber, tsObject as objLit, tsOptions as opt
 import { wireExprBody } from './core/wire-expr.js';
 import { hasExits } from './core/step-ports.js';
 import { readFlowGlobals } from './flow-variables.js';
+import { FLOW_TYPE_NAMES, nonFlowTypeReplacement, runtimeEquivalentFlowType } from './flow-types.js';
 import { outputBackingGlobal, outputBackingName } from './flow-output-backing.js';
 import { mapJsCode } from './core/js-code-spans.js';
 import { VARS_READ_RE } from './core/vars-read.js';
@@ -1272,15 +1273,42 @@ function camel(id) {
     return head.charAt(0).toLowerCase() + head.slice(1) + rest.map((r) => r.charAt(0).toUpperCase() + r.slice(1)).join('');
 }
 // ─── Variables ────────────────────────────────────────────────────────────────
-const TYPE_NAMES = new Set([
-    'string', 'number', 'boolean', 'object', 'array', 'file', 'any',
-    'integer', 'float', 'double', 'date', 'datetime',
-]);
-/** `types.<name>` when the type is a known descriptor, else a defensive string literal. */
-function typeExpr(type, imp) {
-    if (TYPE_NAMES.has(type))
-        return `${imp.use('types')}.${type}`;
-    return tsLiteral(type);
+const TYPE_NAMES = new Set(FLOW_TYPE_NAMES);
+/**
+ * `types.<name>` for a global's type (#861).
+ *
+ * A Flow type prints as itself. Every other type warns once per variable (an
+ * error when `bestEffort` is false), and then:
+ *  - `date` / `datetime` print as `types.string`, the type Flow packaging
+ *    already gives them, so an untouched global never blocks a brownfield
+ *    edit. The recompiled `.flow` says `"type":"string"`; the warning says so.
+ *  - `float`, `double` and `jsonSchema` print as written (`types.float`),
+ *    because a recompile would lose a format or a schema kind: the declaration
+ *    is a TypeScript error and `DECLARATION_TYPE_NOT_FLOW` at build until the
+ *    author picks the type the warning names.
+ *  - any other string prints as a string literal: `DECLARATION_TYPE_UNKNOWN`.
+ */
+function typeExpr(g, imp) {
+    if (TYPE_NAMES.has(g.type))
+        return `${imp.use('types')}.${g.type}`;
+    const replacement = nonFlowTypeReplacement(g.type);
+    const equivalent = runtimeEquivalentFlowType(g.type);
+    const head = `variable ${tsLiteral(g.id)} has type ${tsLiteral(g.type)}`;
+    const message = equivalent !== undefined
+        ? `${head}, a Case type Flow does not model. The source declares it types.${equivalent}, so a recompile `
+            + `writes "type":"${equivalent}" in its place; nothing changes at run time, because flow pack already `
+            + `writes a ${g.type} as a plain string.`
+        : replacement !== undefined
+            ? `${head}, a Case type Flow does not model (packaging and the Workbench do not know it). The source `
+                + `keeps types.${g.type}, which the builder refuses (DECLARATION_TYPE_NOT_FLOW): declare it as ${replacement}.`
+            : `${head}, which is not a Flow type. The source keeps it as a string, which the builder refuses `
+                + `(DECLARATION_TYPE_UNKNOWN): declare one of ${FLOW_TYPE_NAMES.map((t) => `types.${t}`).join(', ')}.`;
+    if (runStrict)
+        throw new Error(`decompile: ${message}`);
+    warnOnce(message);
+    if (equivalent !== undefined)
+        return `${imp.use('types')}.${equivalent}`;
+    return replacement !== undefined ? `${imp.use('types')}.${g.type}` : tsLiteral(g.type);
 }
 /**
  * A global carrying metadata decompiles to the rich VarSpec spelling
@@ -1300,8 +1328,8 @@ function declExpr(g, withDefault, imp, shared) {
     if (shared !== undefined)
         meta.push(`shared: ${tsLiteral(shared)}`);
     if (meta.length === 0)
-        return typeExpr(g.type, imp);
-    return `{ type: ${typeExpr(g.type, imp)}, ${meta.join(', ')} }`;
+        return typeExpr(g, imp);
+    return `{ type: ${typeExpr(g, imp)}, ${meta.join(', ')} }`;
 }
 function sharedCopies(flow, triggers) {
     const globals = readFlowGlobals(flow.variables, runStrict);

package/dist/flow-sdk.d.ts

@@ -38,7 +38,9 @@ export * from './core/lookups.js';
 export * from './core/node-classes.js';
 export * from './raw-node.js';
 import { Expr } from './core/expr.js';
-import type { ErrorEnvelopeField, TypeDesc } from './core/expr.js';
+import type { ErrorEnvelopeField } from './core/expr.js';
+import { type FlowTypeDesc } from './flow-types.js';
+export type { FlowTypeDesc } from './flow-types.js';
 import type { ActionSpec, EventSubscription, TriggerOptions } from './core/actions.js';
 import type { FlowAction, FlowTrigger } from './core/node-classes.js';
 import type { TriggerDescriptor } from './core/connectors.js';
@@ -60,7 +62,7 @@ export type ChildFlow = BuiltFlow | {
 };
 export interface VarDecl {
     name: string;
-    type: TypeDesc;
+    type: FlowTypeDesc;
     default?: unknown;
     /** Human-readable description, persisted on the variable. */
     description?: string;
@@ -80,7 +82,7 @@ export interface VarDecl {
  */
 export interface VarSpec {
     /** The variable's type, one of the `types.*` descriptors. */
-    type: TypeDesc;
+    type: FlowTypeDesc;
     /** Human-readable description, persisted on the variable. */
     description?: string;
     /** Sub-type for complex types (e.g. an array's item type). */
@@ -1563,7 +1565,7 @@ declare class FlowBuilder extends StepList {
      * @returns This builder, so calls chain.
      */
     entryPoint(id: string, trigger: TriggerSpec | FlowTrigger, options?: Pick<NodeOptions, 'version' | 'label'> & {
-        inputs?: Record<string, TypeDesc | VarSpec>;
+        inputs?: Record<string, FlowTypeDesc | VarSpec>;
     }, prefixFn?: (b: StepList) => void): this;
     /**
      * Rename the trigger node. The designer can rename it, so the SDK can too.
@@ -1732,7 +1734,7 @@ declare class FlowBuilder extends StepList {
      * @returns This builder, so calls chain.
      * @see input
      */
-    input(shape: Record<string, TypeDesc | VarSpec>): this;
+    input(shape: Record<string, FlowTypeDesc | VarSpec>): this;
     /**
      * Declare the flow's outputs — what `.return(...)` binds values to.
      *
@@ -1768,7 +1770,7 @@ declare class FlowBuilder extends StepList {
      * @param shape - Output names to type descriptors, e.g. `{ total: types.number }`.
      * @returns This builder, so calls chain.
      */
-    output(shape: Record<string, TypeDesc | VarSpec>): this;
+    output(shape: Record<string, FlowTypeDesc | VarSpec>): this;
     /**
      * Declare a flow-level variable. Read it with `v('<name>')`.
      *
@@ -1778,7 +1780,7 @@ declare class FlowBuilder extends StepList {
      * @returns This builder, so calls chain.
      * @see v
      */
-    var(name: string, type: TypeDesc | VarSpec, defaultValue?: unknown): this;
+    var(name: string, type: FlowTypeDesc | VarSpec, defaultValue?: unknown): this;
     /**
      * Finish the flow and return the graph the compiler serializes.
      *

package/dist/flow-sdk.js

@@ -42,7 +42,8 @@ export * from './core/connectors.js';
 export * from './core/lookups.js';
 export * from './core/node-classes.js';
 export * from './raw-node.js';
-import { err as errRef, toExpr, types } from './core/expr.js';
+import { err as errRef, toExpr } from './core/expr.js';
+import { FLOW_TYPE_NAMES, nonFlowTypeReplacement } from './flow-types.js';
 import { builtinActionSpec, builtinTriggerSpec, subscriptionFrom } from './core/actions.js';
 import { checkFlowExpressions, FlowBuildError } from './flow-expr-check.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
@@ -50,7 +51,6 @@ import { schemaVersionRefusal } from './schema-version.js';
 import { indexCarriedDefinitions } from './core/carried-definitions.js';
 import { CompileRefusal } from './core/compile-refusal.js';
 export { FlowBuildError, checkFlowExpressions } from './flow-expr-check.js';
-const TYPE_NAMES = Object.values(types);
 /**
  * Reject a `.input()` / `.output()` argument that is not a `{ name: type }` map.
  *
@@ -79,7 +79,7 @@ function assertShape(method, shape) {
     return shape;
 }
 /**
- * Normalize a `TypeDesc | VarSpec` declaration value into VarDecl fields.
+ * Normalize a `FlowTypeDesc | VarSpec` declaration value into VarDecl fields.
  * Every direction takes a `default`: the format's `workflowVariableSchema` allows
  * `defaultValue` on `in`, `out` and `inout` alike, and the v1 CLI's
  * `variable add --direction out --default-value` writes one on an output.
@@ -111,12 +111,26 @@ function varDeclOf(method, name, value) {
     assertType(method, name, value);
     return { type: value };
 }
-/** A declared variable's type must be one of the seven `types.*` names. */
+/**
+ * A declared variable's type must be a Flow type ({@link FlowTypeDesc}).
+ *
+ * TypeScript already refuses `types.date` here; this is the same rule for a
+ * caller TypeScript does not check (plain JS, a type built at run time).
+ * A Case-only member of `types` gets its own code, `DECLARATION_TYPE_NOT_FLOW`,
+ * naming the Flow type to use; anything else is `DECLARATION_TYPE_UNKNOWN`.
+ */
 function assertType(method, name, type) {
-    if (typeof type === 'string' && TYPE_NAMES.includes(type))
+    if (typeof type === 'string' && FLOW_TYPE_NAMES.includes(type))
         return;
+    const flowTypes = FLOW_TYPE_NAMES.map((t) => `types.${t}`).join(', ');
+    const replacement = typeof type === 'string' ? nonFlowTypeReplacement(type) : undefined;
+    if (replacement !== undefined) {
+        throw new CompileRefusal('DECLARATION_TYPE_NOT_FLOW', `.${method}() declared ${JSON.stringify(name)} with types.${String(type)}, which is a Case type: `
+            + `Flow does not model it (packaging and the Workbench do not know it). Use ${replacement}. `
+            + `A Flow variable takes one of ${flowTypes}.`);
+    }
     throw new CompileRefusal('DECLARATION_TYPE_UNKNOWN', `.${method}() declared ${JSON.stringify(name)} with type ${JSON.stringify(type)}, which is not `
-        + `a type. Use one of ${TYPE_NAMES.map((t) => `types.${t}`).join(', ')}.`);
+        + `a type. Use one of ${flowTypes}.`);
 }
 // ─── Triggers (what starts the flow) ────────────────────────────────────────
 //

package/dist/flow-types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Which `types.*` descriptors a Flow variable may declare.
+ *
+ * `types` (`core/expr.ts`) is one vocabulary for every builder, but Flow models
+ * fewer types than Case does. Before this split, `flow().input({ d: types.date })`
+ * passed `check`, compiled, and carried `"type":"date"` into the `.flow`
+ * (UiPath/builder-sdk#861). This module is the Flow side of the split: the
+ * builder's `.input` / `.output` / `.var` take a {@link FlowTypeDesc}, and its
+ * run-time guard and the decompiler read {@link FLOW_TYPE_NAMES}.
+ */
+import type { TypeDesc } from './core/expr.js';
+/**
+ * Every `types.*` member, and whether Flow takes it. A `string` value is the
+ * Flow type to use instead, for the refusal message.
+ *
+ * Flow's own tools agree on the `true` set:
+ *  - the Workbench variable picker offers `string number boolean object array file`;
+ *  - `flow pack` (`@uipath/flow-schema` `mapTypeToJsonSchema`) and the canvas
+ *    expression model (`mapTypeToTypeScript`) both map `integer` to an integer
+ *    / number, and `uip maestro flow validate` accepts it (UiPath/cli#5616);
+ *  - `any` is the SDK's own untyped declaration (typeless in an agent schema).
+ *
+ * The others are Case-only. Packaging turns `date` / `datetime` into a plain
+ * `string` with no format, the expression model types `float` / `double` /
+ * `jsonSchema` as `any`, and no Flow editor offers any of them.
+ *
+ * `satisfies Record<TypeDesc, …>` makes this exhaustive: adding a type to
+ * `types` without deciding whether Flow takes it is a compile error here.
+ */
+declare const flowTypeSupport: {
+    readonly string: true;
+    readonly number: true;
+    readonly boolean: true;
+    readonly object: true;
+    readonly array: true;
+    readonly file: true;
+    readonly any: true;
+    readonly integer: true;
+    readonly float: "types.number";
+    readonly double: "types.number";
+    readonly date: "types.string";
+    readonly datetime: "types.string";
+    readonly jsonSchema: "types.object or types.array, with its shape in { schema }";
+};
+/**
+ * A `types.*` descriptor a Flow variable may declare: every member of `types`
+ * but the Case-only `float`, `double`, `date`, `datetime` and `jsonSchema`.
+ */
+export type FlowTypeDesc = {
+    [K in TypeDesc]: (typeof flowTypeSupport)[K] extends true ? K : never;
+}[TypeDesc];
+/** The `types.*` names a Flow variable may declare, in `types` order. */
+export declare const FLOW_TYPE_NAMES: readonly FlowTypeDesc[];
+/**
+ * For a `types.*` name Flow does not take, what to declare instead
+ * (`'date'` → `'types.string'`). `undefined` for a Flow type, and for a name
+ * that is not in `types` at all.
+ */
+export declare function nonFlowTypeReplacement(type: string): string | undefined;
+/**
+ * The Flow type a Case-only type already IS once Flow packages it, for the
+ * ones where the two are the same at run time: `date` and `datetime`, which
+ * `flow pack` (`mapTypeToJsonSchema`) writes as a plain `string` with no
+ * format. Decompile prints this type for such a global, so a `.flow` that an
+ * older SDK or Studio Web wrote still round-trips; the recompile writes
+ * `"type":"string"`, which the decompile warning announces.
+ *
+ * `undefined` for every other type: `float` / `double` lose a format and
+ * `jsonSchema` a schema kind, so those keep the builder's hard stop.
+ */
+export declare function runtimeEquivalentFlowType(type: string): FlowTypeDesc | undefined;
+export {};

package/dist/flow-types.js

@@ -0,0 +1,62 @@
+/**
+ * Every `types.*` member, and whether Flow takes it. A `string` value is the
+ * Flow type to use instead, for the refusal message.
+ *
+ * Flow's own tools agree on the `true` set:
+ *  - the Workbench variable picker offers `string number boolean object array file`;
+ *  - `flow pack` (`@uipath/flow-schema` `mapTypeToJsonSchema`) and the canvas
+ *    expression model (`mapTypeToTypeScript`) both map `integer` to an integer
+ *    / number, and `uip maestro flow validate` accepts it (UiPath/cli#5616);
+ *  - `any` is the SDK's own untyped declaration (typeless in an agent schema).
+ *
+ * The others are Case-only. Packaging turns `date` / `datetime` into a plain
+ * `string` with no format, the expression model types `float` / `double` /
+ * `jsonSchema` as `any`, and no Flow editor offers any of them.
+ *
+ * `satisfies Record<TypeDesc, …>` makes this exhaustive: adding a type to
+ * `types` without deciding whether Flow takes it is a compile error here.
+ */
+const flowTypeSupport = {
+    string: true,
+    number: true,
+    boolean: true,
+    object: true,
+    array: true,
+    file: true,
+    any: true,
+    integer: true,
+    float: 'types.number',
+    double: 'types.number',
+    date: 'types.string',
+    datetime: 'types.string',
+    jsonSchema: 'types.object or types.array, with its shape in { schema }',
+};
+/** The `types.*` names a Flow variable may declare, in `types` order. */
+export const FLOW_TYPE_NAMES = Object.entries(flowTypeSupport)
+    .filter(([, support]) => support === true)
+    .map(([name]) => name);
+/**
+ * For a `types.*` name Flow does not take, what to declare instead
+ * (`'date'` → `'types.string'`). `undefined` for a Flow type, and for a name
+ * that is not in `types` at all.
+ */
+export function nonFlowTypeReplacement(type) {
+    if (!Object.prototype.hasOwnProperty.call(flowTypeSupport, type))
+        return undefined;
+    const support = flowTypeSupport[type];
+    return support === true ? undefined : support;
+}
+/**
+ * The Flow type a Case-only type already IS once Flow packages it, for the
+ * ones where the two are the same at run time: `date` and `datetime`, which
+ * `flow pack` (`mapTypeToJsonSchema`) writes as a plain `string` with no
+ * format. Decompile prints this type for such a global, so a `.flow` that an
+ * older SDK or Studio Web wrote still round-trips; the recompile writes
+ * `"type":"string"`, which the decompile warning announces.
+ *
+ * `undefined` for every other type: `float` / `double` lose a format and
+ * `jsonSchema` a schema kind, so those keep the builder's hard stop.
+ */
+export function runtimeEquivalentFlowType(type) {
+    return type === 'date' || type === 'datetime' ? 'string' : undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.69.0",
+  "version": "6.70.0",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -100,5 +100,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "f1c4fc99c993d7cc8defcda32496be344f018a23"
+  "gitref": "990446f9254b96a4cb0cbfc1a3ec7f99deaabe5e"
 }