@cadenza.io/service 2.17.7 → 2.17.9

package/dist/browser/index.mjs

@@ -5631,10 +5631,29 @@ function buildActorRegistrationData(actor) {
     version: 1
   };
 }
+function resolveSyncServiceName(task) {
+  const taskServiceName = typeof task?.serviceName === "string" ? task.serviceName.trim() : "";
+  const registryServiceName = typeof CadenzaService.serviceRegistry.serviceName === "string" ? CadenzaService.serviceRegistry.serviceName.trim() : "";
+  return taskServiceName || registryServiceName || void 0;
+}
+function buildIntentRegistryData(intent) {
+  const name = String(intent?.name ?? "").trim();
+  if (!name) {
+    return null;
+  }
+  return {
+    name,
+    description: typeof intent?.description === "string" ? intent.description : "",
+    input: intent?.input && typeof intent.input === "object" ? intent.input : { type: "object" },
+    output: intent?.output && typeof intent.output === "object" ? intent.output : { type: "object" },
+    isMeta: isMetaIntentName(name)
+  };
+}
 var GraphSyncController = class _GraphSyncController {
   constructor() {
     this.registeredActors = /* @__PURE__ */ new Set();
     this.registeredActorTaskMaps = /* @__PURE__ */ new Set();
+    this.registeredIntentDefinitions = /* @__PURE__ */ new Set();
     this.isCadenzaDBReady = false;
   }
   static get instance() {
@@ -5642,11 +5661,27 @@ var GraphSyncController = class _GraphSyncController {
     return this._instance;
   }
   init() {
+    const insertIntentRegistryTask = this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(
+      "intent_registry",
+      {
+        onConflict: {
+          target: ["name"],
+          action: {
+            do: "nothing"
+          }
+        }
+      },
+      { concurrency: 30 }
+    ) : CadenzaService.get("dbInsertIntentRegistry");
     this.splitRoutinesTask = CadenzaService.createMetaTask(
       "Split routines for registration",
       async function* (ctx, emit) {
         const { routines } = ctx;
         if (!routines) return;
+        const serviceName = resolveSyncServiceName();
+        if (!serviceName) {
+          return;
+        }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 2e3
         });
@@ -5657,7 +5692,7 @@ var GraphSyncController = class _GraphSyncController {
               name: routine.name,
               version: routine.version,
               description: routine.description,
-              serviceName: CadenzaService.serviceRegistry.serviceName,
+              serviceName,
               isMeta: routine.isMeta
             },
             __routineName: routine.name
@@ -5699,6 +5734,10 @@ var GraphSyncController = class _GraphSyncController {
       function* (ctx) {
         const { routines } = ctx;
         if (!routines) return;
+        const serviceName = resolveSyncServiceName();
+        if (!serviceName) {
+          return;
+        }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
@@ -5718,7 +5757,7 @@ var GraphSyncController = class _GraphSyncController {
                   taskVersion: nextTask.version,
                   routineName: routine.name,
                   routineVersion: routine.version,
-                  serviceName: CadenzaService.serviceRegistry.serviceName
+                  serviceName
                 },
                 __routineName: routine.name,
                 __taskName: nextTask.name
@@ -5821,6 +5860,10 @@ var GraphSyncController = class _GraphSyncController {
           delayMs: 3e3
         });
         const tasks = ctx.tasks;
+        const serviceName = resolveSyncServiceName();
+        if (!serviceName) {
+          return;
+        }
         for (const task of tasks) {
           if (task.registered) continue;
           const { __functionString, __getTagCallback } = task.export();
@@ -5850,7 +5893,7 @@ var GraphSyncController = class _GraphSyncController {
               retryDelay: task.retryDelay,
               retryDelayMax: task.retryDelayMax,
               retryDelayFactor: task.retryDelayFactor,
-              service_name: CadenzaService.serviceRegistry.serviceName,
+              service_name: serviceName,
               signals: {
                 emits: Array.from(task.emitsSignals),
                 signalsToEmitAfter: Array.from(task.signalsToEmitAfter),
@@ -5898,11 +5941,15 @@ var GraphSyncController = class _GraphSyncController {
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
+        const serviceName = resolveSyncServiceName();
+        if (!serviceName) {
+          return;
+        }
         const actors = ctx.actors ?? [];
         for (const actor of actors) {
           const data = {
             ...buildActorRegistrationData(actor),
-            service_name: CadenzaService.serviceRegistry.serviceName
+            service_name: serviceName
           };
           if (!data.name) {
             continue;
@@ -5958,7 +6005,11 @@ var GraphSyncController = class _GraphSyncController {
         if (!metadata?.actorName) {
           return;
         }
-        const registrationKey = `${metadata.actorName}|${task.name}|${task.version}|${CadenzaService.serviceRegistry.serviceName}`;
+        const serviceName = resolveSyncServiceName(task);
+        if (!serviceName) {
+          return;
+        }
+        const registrationKey = `${metadata.actorName}|${task.name}|${task.version}|${serviceName}`;
         if (this.registeredActorTaskMaps.has(registrationKey)) {
           return;
         }
@@ -5968,7 +6019,7 @@ var GraphSyncController = class _GraphSyncController {
             actor_version: 1,
             task_name: task.name,
             task_version: task.version,
-            service_name: CadenzaService.serviceRegistry.serviceName,
+            service_name: serviceName,
             mode: metadata.mode,
             description: task.description ?? metadata.actorDescription ?? "",
             is_meta: metadata.actorKind === "meta" || task.isMeta === true
@@ -6023,6 +6074,10 @@ var GraphSyncController = class _GraphSyncController {
       function* (ctx) {
         const task = ctx.task;
         if (task.hidden || !task.register) return;
+        const serviceName = resolveSyncServiceName(task);
+        if (!serviceName) {
+          return;
+        }
         for (const signal of task.observedSignals) {
           const _signal = signal.split(":")[0];
           if (task.registeredSignals.has(signal)) continue;
@@ -6033,7 +6088,7 @@ var GraphSyncController = class _GraphSyncController {
               isGlobal,
               taskName: task.name,
               taskVersion: task.version,
-              serviceName: CadenzaService.serviceRegistry.serviceName
+              serviceName
             },
             __taskName: task.name,
             __signal: signal
@@ -6059,6 +6114,46 @@ var GraphSyncController = class _GraphSyncController {
         { concurrency: 30 }
       ) : CadenzaService.get("dbInsertSignalToTaskMap"))?.then(registerSignalTask)
     );
+    this.splitIntentsTask = CadenzaService.createMetaTask(
+      "Split intents for registration",
+      function* (ctx) {
+        CadenzaService.debounce("meta.sync_controller.synced_resource", {
+          delayMs: 3e3
+        });
+        const intents = Array.isArray(ctx.intents) ? ctx.intents : Array.from(CadenzaService.inquiryBroker.intents.values());
+        for (const intent of intents) {
+          const intentData = buildIntentRegistryData(intent);
+          if (!intentData) {
+            continue;
+          }
+          if (this.registeredIntentDefinitions.has(intentData.name)) {
+            continue;
+          }
+          yield {
+            data: intentData,
+            __intentName: intentData.name
+          };
+        }
+      }.bind(this)
+    ).then(
+      insertIntentRegistryTask?.then(
+        CadenzaService.createMetaTask("Record intent definition registration", (ctx) => {
+          if (!ctx.__syncing) {
+            return;
+          }
+          CadenzaService.debounce("meta.sync_controller.synced_resource", {
+            delayMs: 3e3
+          });
+          this.registeredIntentDefinitions.add(ctx.__intentName);
+          return true;
+        }).then(
+          CadenzaService.createUniqueMetaTask(
+            "Gather intent registration",
+            () => true
+          ).emits("meta.sync_controller.synced_intents")
+        )
+      )
+    );
     const registerIntentTask = CadenzaService.createMetaTask(
       "Record intent registration",
       (ctx) => {
@@ -6078,6 +6173,10 @@ var GraphSyncController = class _GraphSyncController {
       function* (ctx) {
         const task = ctx.task;
         if (task.hidden || !task.register) return;
+        const serviceName = resolveSyncServiceName(task);
+        if (!serviceName) {
+          return;
+        }
         task.__registeredIntents = task.__registeredIntents ?? /* @__PURE__ */ new Set();
         task.__invalidMetaIntentWarnings = task.__invalidMetaIntentWarnings ?? /* @__PURE__ */ new Set();
         for (const intent of task.handlesIntents) {
@@ -6097,36 +6196,75 @@ var GraphSyncController = class _GraphSyncController {
             }
             continue;
           }
+          const intentDefinition = buildIntentRegistryData(CadenzaService.inquiryBroker.intents.get(intent)) ?? buildIntentRegistryData({ name: intent });
+          if (!intentDefinition) {
+            continue;
+          }
           yield {
             data: {
               intentName: intent,
               taskName: task.name,
               taskVersion: task.version,
-              serviceName: CadenzaService.serviceRegistry.serviceName
+              serviceName
             },
             __taskName: task.name,
-            __intent: intent
+            __intent: intent,
+            __intentDefinition: intentDefinition,
+            __intentMapData: {
+              intentName: intent,
+              taskName: task.name,
+              taskVersion: task.version,
+              serviceName
+            }
           };
         }
       }
     ).then(
-      (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(
-        "intent_to_task_map",
-        {
-          onConflict: {
-            target: [
-              "intent_name",
-              "task_name",
-              "task_version",
-              "service_name"
-            ],
-            action: {
-              do: "nothing"
-            }
+      CadenzaService.createMetaTask(
+        "Prepare intent definition for intent-to-task map",
+        (ctx) => {
+          if (!ctx.__intentDefinition || !ctx.__intentMapData) {
+            return false;
           }
-        },
-        { concurrency: 30 }
-      ) : CadenzaService.get("dbInsertIntentToTaskMap"))?.then(registerIntentTask)
+          return {
+            ...ctx,
+            data: ctx.__intentDefinition
+          };
+        }
+      ).then(
+        insertIntentRegistryTask?.then(
+          CadenzaService.createMetaTask(
+            "Restore intent-to-task map payload",
+            (ctx) => {
+              if (!ctx.__intentMapData) {
+                return false;
+              }
+              return {
+                ...ctx,
+                data: ctx.__intentMapData
+              };
+            }
+          ).then(
+            (this.isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(
+              "intent_to_task_map",
+              {
+                onConflict: {
+                  target: [
+                    "intent_name",
+                    "task_name",
+                    "task_version",
+                    "service_name"
+                  ],
+                  action: {
+                    do: "nothing"
+                  }
+                }
+              },
+              { concurrency: 30 }
+            ) : CadenzaService.get("dbInsertIntentToTaskMap"))?.then(registerIntentTask)
+          )
+        )
+      )
     );
     this.registerTaskMapTask = CadenzaService.createMetaTask(
       "Register task map to DB",
@@ -6136,18 +6274,26 @@ var GraphSyncController = class _GraphSyncController {
           delayMs: 3e3
         });
         if (task.hidden || !task.register) return;
+        const predecessorServiceName = resolveSyncServiceName(task);
+        if (!predecessorServiceName) {
+          return;
+        }
         for (const t of task.nextTasks) {
           if (task.taskMapRegistration.has(t.name) || t.hidden || !t.register) {
             continue;
           }
+          const serviceName = resolveSyncServiceName(t);
+          if (!serviceName) {
+            continue;
+          }
           yield {
             data: {
               taskName: t.name,
               taskVersion: t.version,
               predecessorTaskName: task.name,
               predecessorTaskVersion: task.version,
-              serviceName: CadenzaService.serviceRegistry.serviceName,
-              predecessorServiceName: CadenzaService.serviceRegistry.serviceName
+              serviceName,
+              predecessorServiceName
             },
             __taskName: task.name,
             __nextTaskName: t.name
@@ -6194,14 +6340,19 @@ var GraphSyncController = class _GraphSyncController {
         if (task.hidden || !task.register) return;
         if (task.isDeputy && !task.signalName) {
           if (task.registeredDeputyMap) return;
+          const serviceName = resolveSyncServiceName(task);
+          const predecessorServiceName = resolveSyncServiceName();
+          if (!serviceName || !predecessorServiceName) {
+            return;
+          }
           return {
             data: {
               task_name: task.remoteRoutineName,
               task_version: 1,
-              service_name: task.serviceName,
+              service_name: serviceName,
               predecessor_task_name: task.name,
               predecessor_task_version: task.version,
-              predecessor_service_name: CadenzaService.serviceRegistry.serviceName
+              predecessor_service_name: predecessorServiceName
             },
             __taskName: task.name
           };
@@ -6246,6 +6397,12 @@ var GraphSyncController = class _GraphSyncController {
       "meta.service_registry.initial_sync_complete"
     ).then(this.splitSignalsTask);
     CadenzaService.registry.getAllTasks.clone().doOn("meta.sync_controller.synced_signals").then(this.splitTasksForRegistration);
+    CadenzaService.createMetaTask("Get all intents", (ctx) => {
+      return {
+        ...ctx,
+        intents: Array.from(CadenzaService.inquiryBroker.intents.values())
+      };
+    }).doOn("meta.sync_controller.synced_tasks").then(this.splitIntentsTask);
     CadenzaService.registry.getAllRoutines.clone().doOn("meta.sync_controller.synced_tasks").then(this.splitRoutinesTask);
     CadenzaService.createMetaTask("Get all actors", (ctx) => {
       return {
@@ -6256,9 +6413,9 @@ var GraphSyncController = class _GraphSyncController {
     CadenzaService.registry.doForEachTask.clone().doOn("meta.sync_controller.synced_tasks").then(
       this.registerTaskMapTask,
       this.registerSignalToTaskMapTask,
-      this.registerIntentToTaskMapTask,
       this.registerDeputyRelationshipTask
     );
+    CadenzaService.registry.doForEachTask.clone().doOn("meta.sync_controller.synced_tasks", "meta.sync_controller.synced_intents").then(this.registerIntentToTaskMapTask);
     CadenzaService.registry.doForEachTask.clone().doOn("meta.sync_controller.synced_tasks", "meta.sync_controller.synced_actors").then(this.registerActorTaskMapTask);
     CadenzaService.registry.getAllRoutines.clone().doOn("meta.sync_controller.synced_routines").then(this.splitTasksInRoutines);
     CadenzaService.createMetaTask("Finish sync", (ctx, emit) => {
@@ -6325,6 +6482,15 @@ function readConfiguredPort(value) {
 function buildBootstrapUrl(protocol, address, port) {
   return `${protocol}://${address}:${port}`;
 }
+function readExplicitPortFromOrigin(raw) {
+  const match = raw.match(
+    /^[a-z]+:\/\/(?:\[[^\]]+\]|[^\/?#:]+):(\d+)(?:\/)?$/i
+  );
+  if (!match?.[1]) {
+    return void 0;
+  }
+  return readConfiguredPort(match[1]);
+}
 function resolveInjectedBootstrapUrl(injectedGlobalKey) {
   if (typeof globalThis === "undefined") {
     return void 0;
@@ -6414,7 +6580,8 @@ function resolveBootstrapEndpoint(options) {
         "Bootstrap URL must be an origin without a path component."
       );
     }
-    const port2 = parsed2.port ? readConfiguredPort(parsed2.port) : fallbackPort;
+    const explicitPort = readExplicitPortFromOrigin(raw);
+    const port2 = explicitPort ?? (parsed2.port ? readConfiguredPort(parsed2.port) : fallbackPort);
     if (!port2) {
       throw new Error(
         "Bootstrap URL must include a port or CADENZA_DB_PORT must be provided."
@@ -6508,9 +6675,9 @@ var CadenzaService = class {
   static normalizeDeclaredTransports(transports, serviceId) {
     return (transports ?? []).map((transport) => normalizeServiceTransportConfig(transport)).filter(
       (transport) => !!transport
-    ).map((transport, index) => ({
+    ).map((transport) => ({
       ...transport,
-      uuid: `${serviceId}-transport-${index + 1}`
+      uuid: uuid3()
     }));
   }
   static createBootstrapTransport(serviceInstanceId, role, endpoint) {