@uipath/maestro-builder-sdk 6.68.0 → 6.68.1

package/dist/core/library.js

@@ -337,11 +337,13 @@ export class Library {
             // START form of none (448 `.event.` entries, 0 `.trigger.`; only the curated
             // overlay adds a handful of `.trigger.` pairs). The platform ships both for
             // one operation and the namespace is the only difference, so the start form
-            // is DERIVED from its wait sibling here — measured against the platform's
-            // own `registry get` answers for both forms (see `deriveTriggerForm`).
-            if (kind !== 'trigger')
+            // is DERIVED from its wait sibling — measured against the platform's own
+            // `registry get` answers for both forms (see `deriveTriggerForm`).
+            // `eventFallback` is the one place that says so; `identifyEvent` reads it too.
+            const fallback = eventFallback(kind);
+            if (!fallback)
                 throw error;
-            const siblingType = `uipath.connector.event.${key}.${event}`;
+            const siblingType = `uipath.connector.${fallback.ns}.${key}.${event}`;
             let sibling;
             try {
                 sibling = this.resolveType(siblingType, version, objectName);
@@ -355,7 +357,7 @@ export class Library {
                     throw siblingError;
                 throw error;
             }
-            rc = deriveTriggerForm(sibling, nodeType);
+            rc = fallback.derive(sibling, nodeType);
         }
         return normalizeEventOperation(rc);
     }
@@ -365,31 +367,40 @@ export class Library {
      * {@link identifyAction} for connector activities.
      */
     identifyEvent(kind, wire) {
-        const prefix = `uipath.connector.${kind}.${wire.connectorKey}.`;
-        for (const layer of this.layers) {
-            for (const indexed of layer.entries) {
-                if (indexed.connectorKey !== wire.connectorKey || !String(indexed.nodeType ?? '').startsWith(prefix))
-                    continue;
-                if (wire.version && indexed.version !== wire.version)
-                    continue;
-                const entryPath = libraryPath(layer.dir, indexed.path);
-                const entry = readJson(this.read, entryPath);
-                const operation = normalizeEventOperation({ entry, v1def: readV1def(this.read, entryPath) }).entry.operation ?? {};
-                // A GENERIC event's entry names no object — the wire's object is the
-                // author's choice, so it identifies nothing here and comes back as `object`.
-                const generic = operation.activityType === 'GenericTrigger';
-                if (!generic && wire.objectName && operation.objectName !== wire.objectName)
-                    continue;
-                if (wire.eventOperation && operation.eventOperation !== wire.eventOperation)
-                    continue;
-                if (wire.eventMode && operation.eventMode !== wire.eventMode)
-                    continue;
-                return {
-                    key: wire.connectorKey,
-                    event: String(indexed.nodeType).slice(prefix.length),
-                    version: String(indexed.version),
-                    ...(generic && wire.objectName ? { object: wire.objectName } : {}),
-                };
+        // The same sources, in the same order, that `resolveEvent` reads: a trigger
+        // the library carries only in its WAIT form is identified from that entry,
+        // passed through the same derivation compile used to write it (#1073).
+        const fallback = eventFallback(kind);
+        const sources = [{ ns: kind, derive: undefined }, ...(fallback ? [fallback] : [])];
+        for (const source of sources) {
+            const prefix = `uipath.connector.${source.ns}.${wire.connectorKey}.`;
+            for (const layer of this.layers) {
+                for (const indexed of layer.entries) {
+                    if (indexed.connectorKey !== wire.connectorKey || !String(indexed.nodeType ?? '').startsWith(prefix))
+                        continue;
+                    if (wire.version && indexed.version !== wire.version)
+                        continue;
+                    const event = String(indexed.nodeType).slice(prefix.length);
+                    const entryPath = libraryPath(layer.dir, indexed.path);
+                    const read = { entry: readJson(this.read, entryPath), v1def: readV1def(this.read, entryPath) };
+                    const asked = source.derive ? source.derive(read, `uipath.connector.${kind}.${wire.connectorKey}.${event}`) : read;
+                    const operation = normalizeEventOperation(asked).entry.operation ?? {};
+                    // A GENERIC event's entry names no object — the wire's object is the
+                    // author's choice, so it identifies nothing here and comes back as `object`.
+                    const generic = operation.activityType === 'GenericTrigger';
+                    if (!generic && wire.objectName && operation.objectName !== wire.objectName)
+                        continue;
+                    if (wire.eventOperation && operation.eventOperation !== wire.eventOperation)
+                        continue;
+                    if (wire.eventMode && operation.eventMode !== wire.eventMode)
+                        continue;
+                    return {
+                        key: wire.connectorKey,
+                        event,
+                        version: String(indexed.version),
+                        ...(generic && wire.objectName ? { object: wire.objectName } : {}),
+                    };
+                }
             }
         }
         throw new CompileRefusal('EVENT_UNKNOWN', `connector ${kind} event not found in library: ${wire.connectorKey} `
@@ -1146,6 +1157,23 @@ function normalizeEventOperation(rc) {
     };
     return { ...rc, entry: { ...rc.entry, operation: normalized } };
 }
+/**
+ * The fallback the library uses for a connector event of `kind` that its own
+ * namespace cannot resolve, or `undefined` when there is none.
+ *
+ * A start (`trigger`) falls back to its wait form, DERIVED by `deriveTriggerForm`,
+ * because the registry dump ships wait forms only. A wait (`event`) has no
+ * fallback.
+ *
+ * `resolveEvent` (TypeScript to wire) and `identifyEvent` (wire back to
+ * TypeScript) both read this, so the reverse lookup cannot miss an entry the
+ * forward one resolved (#1073: decompile threw "connector trigger event not
+ * found" for every trigger the library carried only as `.event.`).
+ */
+function eventFallback(kind) {
+    return kind === 'trigger' ? TRIGGER_FALLBACK : undefined;
+}
+const TRIGGER_FALLBACK = { ns: 'event', derive: (rc, nodeType) => deriveTriggerForm(rc, nodeType) };
 /**
  * Derive a connector event's START form (`uipath.connector.trigger.<key>.<event>`)
  * from its WAIT form (`uipath.connector.event.<key>.<event>`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.68.0",
+  "version": "6.68.1",
   "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": "e00e90da685347c0a5b2f9ef0fafee9e0b980c4d"
+  "gitref": "cc5d3156131d305c073258591e362deb7f4fbbde"
 }