@uipath/maestro-builder-sdk 6.69.1 → 6.70.0

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.69.1",
+  "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": "f2e643fd7aeb11ab748bb281be50d24fe339bf52"
+  "gitref": "990446f9254b96a4cb0cbfc1a3ec7f99deaabe5e"
 }