@cadenza.io/service 2.17.74 → 2.17.76

package/dist/browser/index.mjs

@@ -1161,39 +1161,12 @@ var ServiceRegistry = class _ServiceRegistry {
         if (trackedInstance?.isFrontend) {
           return true;
         }
-        const trackedTransport = this.getRouteableTransport(
-          trackedInstance,
-          this.useSocket ? "socket" : "rest"
-        );
         if (this.deputies.has(serviceName) || this.remoteIntents.has(serviceName) || this.remoteSignals.has(serviceName)) {
-          const communicationTypes = Array.from(
-            new Set(
-              this.deputies.get(serviceName)?.map((d) => d.communicationType) ?? []
-            )
+          const connected = this.ensureDependeeClientForInstance(
+            trackedInstance,
+            emit
           );
-          if (!communicationTypes.includes("signal") && this.remoteSignals.has(serviceName)) {
-            communicationTypes.push("signal");
-          }
-          if (trackedTransport) {
-            const clientCreated = this.hasTransportClientCreated(
-              trackedInstance,
-              trackedTransport.uuid
-            );
-            if (!clientCreated) {
-              emit("meta.service_registry.dependee_registered", {
-                serviceName,
-                serviceInstanceId: uuid7,
-                serviceTransportId: trackedTransport.uuid,
-                serviceOrigin: trackedTransport.origin,
-                transportProtocols: trackedTransport.protocols,
-                communicationTypes
-              });
-              this.markTransportClientCreated(
-                trackedInstance,
-                trackedTransport.uuid
-              );
-            }
-          } else {
+          if (!connected) {
             emit("meta.service_registry.routeable_transport_missing", {
               serviceName,
               serviceInstanceId: uuid7,
@@ -1259,25 +1232,7 @@ var ServiceRegistry = class _ServiceRegistry {
         if (!hasRemoteInterest) {
           return true;
         }
-        if (!this.hasTransportClientCreated(ownerInstance, transport.uuid)) {
-          const communicationTypes = Array.from(
-            new Set(
-              this.deputies.get(ownerInstance.serviceName)?.map((descriptor) => descriptor.communicationType) ?? []
-            )
-          );
-          if (!communicationTypes.includes("signal") && this.remoteSignals.has(ownerInstance.serviceName)) {
-            communicationTypes.push("signal");
-          }
-          emit("meta.service_registry.dependee_registered", {
-            serviceName: ownerInstance.serviceName,
-            serviceInstanceId: ownerInstance.uuid,
-            serviceTransportId: transport.uuid,
-            serviceOrigin: transport.origin,
-            transportProtocols: transport.protocols,
-            communicationTypes
-          });
-          this.markTransportClientCreated(ownerInstance, transport.uuid);
-        }
+        this.ensureDependeeClientForInstance(ownerInstance, emit);
         return true;
       },
       "Handles service transport updates independently from instance rows."
@@ -1358,7 +1313,7 @@ var ServiceRegistry = class _ServiceRegistry {
     ).emits("meta.service_registry.registered_global_signals").doOn("global.meta.cadenza_db.gathered_sync_data");
     this.handleGlobalIntentRegistrationTask = CadenzaService.createMetaTask(
       "Handle global intent registration",
-      (ctx) => {
+      (ctx, emit) => {
         const intentToTaskMaps = this.normalizeIntentMaps(ctx);
         const sorted = intentToTaskMaps.sort((a, b) => {
           if (a.deleted && !b.deleted) return -1;
@@ -1374,6 +1329,7 @@ var ServiceRegistry = class _ServiceRegistry {
             name: map.intentName
           });
           this.registerRemoteIntentDeputy(map);
+          this.ensureDependeeClientsForService(map.serviceName, emit);
         }
         return true;
       },
@@ -2799,6 +2755,49 @@ var ServiceRegistry = class _ServiceRegistry {
     }
     return buildTransportClientKey(transport);
   }
+  resolveCommunicationTypesForService(serviceName) {
+    const communicationTypes = Array.from(
+      new Set(
+        this.deputies.get(serviceName)?.map((descriptor) => descriptor.communicationType) ?? []
+      )
+    );
+    if (!communicationTypes.includes("signal") && this.remoteSignals.has(serviceName)) {
+      communicationTypes.push("signal");
+    }
+    return communicationTypes;
+  }
+  ensureDependeeClientForInstance(instance, emit) {
+    if (!instance || instance.uuid === this.serviceInstanceId || instance.isFrontend || !instance.isActive || instance.isNonResponsive || instance.isBlocked) {
+      return false;
+    }
+    if (!this.deputies.has(instance.serviceName) && !this.remoteIntents.has(instance.serviceName) && !this.remoteSignals.has(instance.serviceName)) {
+      return false;
+    }
+    const transport = this.getRouteableTransport(
+      instance,
+      this.useSocket ? "socket" : "rest"
+    );
+    if (!transport || this.hasTransportClientCreated(instance, transport.uuid)) {
+      return false;
+    }
+    emit("meta.service_registry.dependee_registered", {
+      serviceName: instance.serviceName,
+      serviceInstanceId: instance.uuid,
+      serviceTransportId: transport.uuid,
+      serviceOrigin: transport.origin,
+      transportProtocols: transport.protocols,
+      communicationTypes: this.resolveCommunicationTypesForService(
+        instance.serviceName
+      )
+    });
+    this.markTransportClientCreated(instance, transport.uuid);
+    return true;
+  }
+  ensureDependeeClientsForService(serviceName, emit) {
+    for (const instance of this.instances.get(serviceName) ?? []) {
+      this.ensureDependeeClientForInstance(instance, emit);
+    }
+  }
   hasTransportClientCreated(instance, transportId) {
     return (instance.clientCreatedTransportIds ?? []).includes(transportId);
   }
@@ -3582,13 +3581,14 @@ var RestController = class _RestController {
     this.diagnosticsErrorHistoryLimit = 100;
     this.diagnosticsMaxClientEntries = 500;
     this.destroyedDiagnosticsTtlMs = 15 * 6e4;
-    this.fetchDataWithTimeout = async function(url, requestInit, timeoutMs) {
+    this.fetchDataWithTimeout = async (url, requestInit, timeoutMs) => {
       if (typeof globalThis.fetch !== "function") {
         throw new Error("Browser REST controller requires global fetch.");
       }
       const signal = AbortSignal.timeout(timeoutMs);
       const response = await globalThis.fetch(url, { ...requestInit, signal });
-      return await response.json();
+      const parsedResponse = await this.parseFetchResponse(response);
+      return parsedResponse.data;
     };
     CadenzaService.createMetaTask(
       "Collect fetch transport diagnostics",
@@ -3934,6 +3934,38 @@ var RestController = class _RestController {
       return String(error);
     }
   }
+  async parseFetchResponse(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    const rawText = await response.text();
+    const headers = Object.fromEntries(response.headers.entries());
+    if (rawText.length === 0) {
+      return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+        data: {}
+      };
+    }
+    if (!contentType.toLowerCase().includes("application/json")) {
+      throw new Error(
+        `Expected JSON response from ${response.url ?? "remote service"} but received ${contentType || "unknown content type"} (HTTP ${response.status}). Body preview: ${rawText.slice(0, 200)}`
+      );
+    }
+    try {
+      return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+        data: JSON.parse(rawText)
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to parse JSON response from ${response.url ?? "remote service"} (HTTP ${response.status}). Body preview: ${rawText.slice(0, 200)}. Parse error: ${this.getErrorMessage(error)}`
+      );
+    }
+  }
   recordFetchClientError(fetchId, serviceName, url, error) {
     const state = this.ensureFetchClientDiagnostics(fetchId, serviceName, url);
     const message = this.getErrorMessage(error);