@uipath/maestro-builder-sdk 6.17.3 → 6.17.4

package/dist/core/cli-library.js

@@ -96,7 +96,8 @@ export function connectorCheckOpts(library, bindings, inputErrors = (rc, inputs,
         },
         // The refusal compile throws for an operation it cannot resolve, with its
         // code and text: CONNECTOR_NOT_IN_LIBRARY, CONNECTOR_OBJECT_REQUIRED,
-        // CONNECTOR_OBJECT_NOT_GENERIC.
+        // CONNECTOR_OBJECT_NOT_GENERIC, CONNECTOR_LIBRARY_ENTRY_UNREADABLE, or
+        // CONNECTOR_RESOLVE_FAILED for any other throw.
         connectorResolveError: (spec) => {
             const r = resolve(spec);
             return 'error' in r ? r.error : undefined;
@@ -114,11 +115,19 @@ export function connectorCheckOpts(library, bindings, inputErrors = (rc, inputs,
         ...(bindings ? { bindings } : {}),
     };
 }
+/** `check`'s code for an untyped throw from `library.resolve`; see {@link connectorResolver}. */
+const CONNECTOR_RESOLVE_FAILED = 'CONNECTOR_RESOLVE_FAILED';
 /**
  * `library.resolve` for one connector step, memoized per step for the life of
- * one check's options. A {@link ConnectorResolveError} is the refusal compile
- * throws and becomes `error`; anything else thrown is not a verdict about the
- * author's source and stays "unknown", as before.
+ * one check's options.
+ *
+ * This is the exact call `serialize` makes, so ANY throw here is a throw compile
+ * makes too, and becomes `error`. A {@link ConnectorResolveError} keeps its own
+ * code (CONNECTOR_NOT_IN_LIBRARY, CONNECTOR_LIBRARY_ENTRY_UNREADABLE, …).
+ * Anything else, which `library.resolve` does not throw on purpose, is reported
+ * as CONNECTOR_RESOLVE_FAILED with its message. Treating an untyped throw as
+ * "unknown" used to let `check` pass a step `compile` then died on (#1015); the
+ * event twin, `eventResolveErrorFor`, already reported every throw.
  */
 function connectorResolver(library) {
     const memo = new Map();
@@ -132,7 +141,7 @@ function connectorResolver(library) {
             catch (error) {
                 r = error instanceof ConnectorResolveError
                     ? { error: { code: error.code, message: error.message } }
-                    : { unknown: true };
+                    : { error: { code: CONNECTOR_RESOLVE_FAILED, message: error instanceof Error ? error.message : String(error) } };
             }
             memo.set(id, r);
         }

package/dist/core/library.d.ts

@@ -225,7 +225,12 @@ export type ConnectorResolveCode =
 /** A GENERIC operation (one entry per object) named without an `object`. */
  | 'CONNECTOR_OBJECT_REQUIRED'
 /** An `object` on a single, non-generic operation. */
- | 'CONNECTOR_OBJECT_NOT_GENERIC';
+ | 'CONNECTOR_OBJECT_NOT_GENERIC'
+/**
+ * The index lists the operation, but its entry file or `.v1def.json` sidecar is
+ * missing or not valid JSON: the library on disk is incomplete (#1015).
+ */
+ | 'CONNECTOR_LIBRARY_ENTRY_UNREADABLE';
 /**
  * The refusal {@link Library.resolve} throws, with a `code` for each reason.
  *

package/dist/core/library.js

@@ -827,8 +827,13 @@ export class Library {
     }
     build(dir, e, nodeType, opts = {}) {
         const entryPath = join(dir, e.path);
-        const entry = JSON.parse(readFileSync(entryPath, 'utf8'));
-        const v1def = readV1def(entryPath);
+        // The two files the index row promises. A missing or corrupt one is a fault in
+        // the library on disk, not in the author's source, but compile cannot go on
+        // without it, so it is a typed refusal like the others: `check` reports it with
+        // the same code and text instead of passing a step compile then dies on with a
+        // bare ENOENT (#1015).
+        const entry = readLibraryFile(nodeType, entryPath, () => JSON.parse(readFileSync(entryPath, 'utf8')));
+        const v1def = readLibraryFile(nodeType, v1defPathOf(entryPath), () => readV1def(entryPath));
         // A stamped object (case 4) reaches here with the index entry's `objectName`
         // replaced but the sibling's FILE on disk — so restate the object and derive
         // the endpoint from the sibling's own template, rather than shipping a node
@@ -944,6 +949,33 @@ function deriveObjectPath(operation, objectName) {
     }
     return out;
 }
+/** The `.v1def.json` sidecar path beside a library entry file. */
+function v1defPathOf(entryPath) {
+    return entryPath.replace(/\.json$/, '.v1def.json');
+}
+/**
+ * Read one file an index row points at, turning a missing or unparsable file
+ * into {@link ConnectorResolveError} `CONNECTOR_LIBRARY_ENTRY_UNREADABLE`.
+ *
+ * The library build refuses to write an entry without its sidecar
+ * (`registry/library-build/plan.ts`), so this only fires for a library that was
+ * damaged after it was built: an interrupted pull, a hand-edited overlay. The
+ * remedy is the same either way: rebuild the layer the file belongs to.
+ */
+function readLibraryFile(nodeType, path, read) {
+    try {
+        return read();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        // ENOENT already names the path; a JSON SyntaxError does not.
+        const reason = message.includes(path) ? message : `${path}: ${message}`;
+        throw new ConnectorResolveError('CONNECTOR_LIBRARY_ENTRY_UNREADABLE', `connector library entry for ${nodeType} is unreadable: ${reason}. The library index lists `
+            + `this operation, but the file is missing or not valid JSON, so the library on disk is incomplete. `
+            + `Refresh it with \`${PULL_COMMAND}\`; if the file is in the \`connectors-local\` overlay, `
+            + `re-run the \`${prepareCommand()}\` that wrote it.`);
+    }
+}
 /**
  * Read the `.v1def.json` sidecar beside a library entry file, with a connection
  * definition's `model.bindings.resource` in the designer's canonical casing.
@@ -961,7 +993,7 @@ function deriveObjectPath(operation, objectName) {
  * validate and debug — which fold the case — passed.
  */
 function readV1def(entryPath) {
-    const raw = JSON.parse(readFileSync(entryPath.replace(/\.json$/, '.v1def.json'), 'utf8'));
+    const raw = JSON.parse(readFileSync(v1defPathOf(entryPath), 'utf8'));
     const v1def = Array.isArray(raw) ? raw[0] : raw;
     const bindings = v1def?.model?.bindings;
     if (typeof bindings?.resource === 'string' && bindings.resource.toLowerCase() === 'connection') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.17.3",
+  "version": "6.17.4",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -92,5 +92,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "8da4aeeb1592a342b2ac705939e646cd77baa891"
+  "gitref": "6a0dfa03e18d92bd2452c96704c1c80fa122fc11"
 }