@cadenza.io/service 2.17.8 → 2.17.10

package/dist/index.js

@@ -433,16 +433,16 @@ function normalizeServiceTransportConfig(value) {
 }
 function normalizeServiceTransportDescriptor(value) {
   const raw = value ?? {};
-  const uuid5 = normalizeString(raw.uuid);
+  const uuid6 = normalizeString(raw.uuid);
   const serviceInstanceId = normalizeString(
     raw.serviceInstanceId ?? raw.service_instance_id
   );
   const config = normalizeServiceTransportConfig(raw);
-  if (!uuid5 || !serviceInstanceId || !config) {
+  if (!uuid6 || !serviceInstanceId || !config) {
     return null;
   }
   return {
-    uuid: uuid5,
+    uuid: uuid6,
     serviceInstanceId,
     role: config.role,
     origin: config.origin,
@@ -504,14 +504,14 @@ function normalizeTransportArray(value, serviceInstanceId) {
 }
 function normalizeServiceInstanceDescriptor(value) {
   const raw = value ?? {};
-  const uuid5 = normalizeString2(raw.uuid);
+  const uuid6 = normalizeString2(raw.uuid);
   const serviceName = normalizeString2(raw.serviceName ?? raw.service_name);
-  if (!uuid5 || !serviceName) {
+  if (!uuid6 || !serviceName) {
     return null;
   }
-  const transports = normalizeTransportArray(raw.transports, uuid5);
+  const transports = normalizeTransportArray(raw.transports, uuid6);
   return {
-    uuid: uuid5,
+    uuid: uuid6,
     serviceName,
     numberOfRunningGraphs: Math.max(
       0,
@@ -954,15 +954,15 @@ var ServiceRegistry = class _ServiceRegistry {
         if (!serviceInstance) {
           return false;
         }
-        const uuid5 = serviceInstance.uuid;
+        const uuid6 = serviceInstance.uuid;
         const serviceName = serviceInstance.serviceName;
         const deleted = Boolean(
           ctx.deleted ?? ctx.serviceInstance?.deleted ?? ctx.data?.deleted
         );
-        if (uuid5 === this.serviceInstanceId) return;
+        if (uuid6 === this.serviceInstanceId) return;
         if (deleted) {
-          const existingInstance = this.instances.get(serviceName)?.find((instance) => instance.uuid === uuid5);
-          const indexToDelete = this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid5) ?? -1;
+          const existingInstance = this.instances.get(serviceName)?.find((instance) => instance.uuid === uuid6);
+          const indexToDelete = this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid6) ?? -1;
           if (indexToDelete >= 0 && existingInstance) {
             this.instances.get(serviceName)?.splice(indexToDelete, 1);
             for (const transport of existingInstance.transports) {
@@ -974,13 +974,13 @@ var ServiceRegistry = class _ServiceRegistry {
           if (this.instances.get(serviceName)?.length === 0) {
             this.instances.delete(serviceName);
           }
-          this.unregisterDependee(uuid5, serviceName);
+          this.unregisterDependee(uuid6, serviceName);
           return;
         }
         if (!this.instances.has(serviceName))
           this.instances.set(serviceName, []);
         const instances = this.instances.get(serviceName);
-        const existing = instances.find((i) => i.uuid === uuid5);
+        const existing = instances.find((i) => i.uuid === uuid6);
         if (existing) {
           Object.assign(existing, {
             ...serviceInstance,
@@ -990,7 +990,7 @@ var ServiceRegistry = class _ServiceRegistry {
         } else {
           instances.push(serviceInstance);
         }
-        const trackedInstance = existing ?? instances.find((instance) => instance.uuid === uuid5);
+        const trackedInstance = existing ?? instances.find((instance) => instance.uuid === uuid6);
         if (trackedInstance) {
           const snapshot = this.resolveRuntimeStatusSnapshot(
             trackedInstance.numberOfRunningGraphs ?? 0,
@@ -1003,7 +1003,7 @@ var ServiceRegistry = class _ServiceRegistry {
           trackedInstance.reportedAt = trackedInstance.reportedAt ?? (/* @__PURE__ */ new Date()).toISOString();
         }
         if (!serviceInstance.isBootstrapPlaceholder) {
-          this.reconcileBootstrapPlaceholderInstance(serviceName, uuid5, emit);
+          this.reconcileBootstrapPlaceholderInstance(serviceName, uuid6, emit);
         }
         if (this.serviceName === serviceName) {
           return false;
@@ -1029,7 +1029,7 @@ var ServiceRegistry = class _ServiceRegistry {
             if (!clientCreated) {
               emit("meta.service_registry.dependee_registered", {
                 serviceName,
-                serviceInstanceId: uuid5,
+                serviceInstanceId: uuid6,
                 serviceTransportId: trackedTransport.uuid,
                 serviceOrigin: trackedTransport.origin,
                 transportProtocols: trackedTransport.protocols,
@@ -1043,7 +1043,7 @@ var ServiceRegistry = class _ServiceRegistry {
           } else {
             emit("meta.service_registry.routeable_transport_missing", {
               serviceName,
-              serviceInstanceId: uuid5,
+              serviceInstanceId: uuid6,
               requiredRole: this.getRoutingTransportRole(),
               isFrontend: this.isFrontend
             });
@@ -3284,6 +3284,7 @@ var import_node_http = __toESM(require("http"));
 var import_node_fs = __toESM(require("fs"));
 var import_node_https = __toESM(require("https"));
 var import_node_fetch = __toESM(require("node-fetch"));
+var import_uuid3 = require("uuid");
 var RestController = class _RestController {
   /**
    * Constructor for initializing the REST server and related configurations.
@@ -3645,7 +3646,7 @@ var RestController = class _RestController {
                   const internalOrigin = httpOrigin ?? httpsOrigin;
                   if (internalOrigin) {
                     transportData.unshift({
-                      uuid: `${ctx.__serviceInstanceId}-internal-auto`,
+                      uuid: (0, import_uuid3.v4)(),
                       service_instance_id: ctx.__serviceInstanceId,
                       role: "internal",
                       origin: internalOrigin,
@@ -5829,6 +5830,13 @@ var GraphMetadataController = class _GraphMetadataController {
       };
     }).doOn("meta.task.layer_index_changed", "meta.task.destroyed").emits("global.meta.graph_metadata.task_updated");
     CadenzaService.createMetaTask("Handle task relationship creation", (ctx) => {
+      const taskName = ctx.data?.taskName ?? ctx.data?.task_name;
+      const predecessorTaskName = ctx.data?.predecessorTaskName ?? ctx.data?.predecessor_task_name;
+      const task = taskName ? CadenzaService.get(taskName) : void 0;
+      const predecessorTask = predecessorTaskName ? CadenzaService.get(predecessorTaskName) : void 0;
+      if (!task?.registered || !predecessorTask?.registered) {
+        return false;
+      }
       return {
         data: {
           ...ctx.data,
@@ -6105,6 +6113,13 @@ function defaultOperationIntentDescription(operation, tableName) {
 function isExplicitSqlLiteral(value) {
   return /^'.*'::[a-z_][a-z0-9_]*(\[\])?$/i.test(value.trim());
 }
+function extractExplicitJsonLiteral(value) {
+  const match = /^'(.*)'::jsonb$/i.exec(value.trim());
+  if (!match) {
+    return null;
+  }
+  return match[1].replace(/''/g, "'");
+}
 function isExplicitSqlExpression(value) {
   const trimmed = value.trim();
   if (!trimmed) {
@@ -6163,6 +6178,24 @@ function serializeInitialDataValueForSql(value, field) {
   }
   return `'${stringValue.replace(/'/g, "''")}'`;
 }
+function serializeFieldValueForQuery(value, field) {
+  if (value === void 0 || value === null || field?.type !== "jsonb") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const explicitJsonLiteral = extractExplicitJsonLiteral(value);
+    if (explicitJsonLiteral !== null) {
+      return explicitJsonLiteral;
+    }
+    try {
+      JSON.parse(value);
+      return value;
+    } catch {
+      return JSON.stringify(value);
+    }
+  }
+  return JSON.stringify(value);
+}
 function readCustomIntentConfig(customIntent) {
   if (typeof customIntent === "string") {
     return {
@@ -6844,18 +6877,28 @@ var DatabaseController = class _DatabaseController {
             throw new Error("No rows available for insert after resolving data");
           }
           const keys = Object.keys(rows[0]);
+          const tableFields = registration.schema.tables[tableName]?.fields ?? {};
           const sqlPrefix = `INSERT INTO ${tableName} (${keys.map((key) => (0, import_lodash_es.snakeCase)(key)).join(", ")}) VALUES `;
           const params = [];
           const placeholders = rows.map((row) => {
             const tuple = keys.map((key) => {
-              params.push(row[key]);
+              params.push(
+                serializeFieldValueForQuery(
+                  row[key],
+                  this.getFieldDefinitionForKey(tableFields, key)
+                )
+              );
               return `$${params.length}`;
             }).join(", ");
             return `(${tuple})`;
           }).join(", ");
           let onConflictSql = "";
           if (onConflict) {
-            onConflictSql = this.buildOnConflictClause(onConflict, params);
+            onConflictSql = this.buildOnConflictClause(
+              onConflict,
+              params,
+              tableFields
+            );
           }
           const sql = `${sqlPrefix}${placeholders}${onConflictSql} RETURNING ${fields.length ? fields.map(import_lodash_es.snakeCase).join(", ") : "*"}`;
           const result = await this.withTimeout(
@@ -6903,27 +6946,26 @@ var DatabaseController = class _DatabaseController {
             data,
             tableName
           );
-          const params = Object.values(resolvedData);
-          let offset = 0;
-          const setClause = Object.keys(resolvedData).map((key, index) => {
+          const tableFields = registration.schema.tables[tableName]?.fields ?? {};
+          const params = [];
+          const setClause = Object.keys(resolvedData).map((key) => {
             const value = resolvedData[key];
-            const offsetIndex = index - offset;
             if (value?.__effect === "increment") {
-              params.splice(offsetIndex, 1);
-              offset += 1;
               return `${(0, import_lodash_es.snakeCase)(key)} = ${(0, import_lodash_es.snakeCase)(key)} + 1`;
             }
             if (value?.__effect === "decrement") {
-              params.splice(offsetIndex, 1);
-              offset += 1;
               return `${(0, import_lodash_es.snakeCase)(key)} = ${(0, import_lodash_es.snakeCase)(key)} - 1`;
             }
             if (value?.__effect === "set") {
-              params.splice(offsetIndex, 1);
-              offset += 1;
               return `${(0, import_lodash_es.snakeCase)(key)} = ${value.__value}`;
             }
-            return `${(0, import_lodash_es.snakeCase)(key)} = $${offsetIndex + 1}`;
+            params.push(
+              serializeFieldValueForQuery(
+                value,
+                this.getFieldDefinitionForKey(tableFields, key)
+              )
+            );
+            return `${(0, import_lodash_es.snakeCase)(key)} = $${params.length}`;
           }).join(", ");
           const whereClause = this.buildWhereClause(filter, params);
           const sql = `UPDATE ${tableName} SET ${setClause} ${whereClause} RETURNING *`;
@@ -7012,7 +7054,7 @@ var DatabaseController = class _DatabaseController {
       retryDelayFactor: Number.isFinite(durableState.safetyPolicy?.retryDelayFactor) ? Math.max(1, Number(durableState.safetyPolicy?.retryDelayFactor)) : 1
     };
   }
-  buildOnConflictClause(onConflict, params) {
+  buildOnConflictClause(onConflict, params, tableFields) {
     const { target, action } = onConflict;
     let sql = ` ON CONFLICT (${target.map(import_lodash_es.snakeCase).join(", ")})`;
     if (action.do === "update") {
@@ -7023,7 +7065,12 @@ var DatabaseController = class _DatabaseController {
         if (typeof value === "string" && value === "excluded") {
           return `${(0, import_lodash_es.snakeCase)(field)} = excluded.${(0, import_lodash_es.snakeCase)(field)}`;
         }
-        params.push(value);
+        params.push(
+          serializeFieldValueForQuery(
+            value,
+            this.getFieldDefinitionForKey(tableFields, field)
+          )
+        );
         return `${(0, import_lodash_es.snakeCase)(field)} = $${params.length}`;
       });
       sql += ` DO UPDATE SET ${assignments.join(", ")}`;
@@ -7035,6 +7082,9 @@ var DatabaseController = class _DatabaseController {
     sql += " DO NOTHING";
     return sql;
   }
+  getFieldDefinitionForKey(fields, key) {
+    return fields[key] ?? fields[(0, import_lodash_es.snakeCase)(key)];
+  }
   /**
    * Validates database schema structure and content.
    */
@@ -7656,7 +7706,13 @@ var DatabaseController = class _DatabaseController {
         );
         const row = ensurePlainObject(resolvedData, "sub-operation insert data");
         const keys = Object.keys(row);
-        const params = Object.values(row);
+        const tableFields = registration.schema.tables[operation.table]?.fields ?? {};
+        const params = keys.map(
+          (key) => serializeFieldValueForQuery(
+            row[key],
+            this.getFieldDefinitionForKey(tableFields, key)
+          )
+        );
         const sql2 = `INSERT INTO ${operation.table} (${keys.map((key) => (0, import_lodash_es.snakeCase)(key)).join(", ")}) VALUES (${params.map((_, index) => `$${index + 1}`).join(", ")}) ON CONFLICT DO NOTHING RETURNING ${operation.return ?? "*"}`;
         const result2 = await this.withTimeout(
           () => client.query(sql2, params),
@@ -8006,7 +8062,7 @@ function tableFieldTypeToSchemaType(type) {
 }
 
 // src/Cadenza.ts
-var import_uuid3 = require("uuid");
+var import_uuid4 = require("uuid");
 
 // src/graph/controllers/GraphSyncController.ts
 var ACTOR_TASK_METADATA = /* @__PURE__ */ Symbol.for("@cadenza.io/core/actor-task-meta");
@@ -8068,10 +8124,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() {
@@ -8079,11 +8154,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
         });
@@ -8094,7 +8185,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
@@ -8136,6 +8227,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
         });
@@ -8155,7 +8250,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
@@ -8258,6 +8353,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();
@@ -8287,7 +8386,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),
@@ -8335,11 +8434,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;
@@ -8395,7 +8498,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;
         }
@@ -8405,7 +8512,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
@@ -8460,6 +8567,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;
@@ -8470,7 +8581,7 @@ var GraphSyncController = class _GraphSyncController {
               isGlobal,
               taskName: task.name,
               taskVersion: task.version,
-              serviceName: CadenzaService.serviceRegistry.serviceName
+              serviceName
             },
             __taskName: task.name,
             __signal: signal
@@ -8496,6 +8607,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) => {
@@ -8515,6 +8666,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) {
@@ -8534,36 +8689,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",
@@ -8573,18 +8767,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
@@ -8631,14 +8833,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
           };
@@ -8683,6 +8890,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 {
@@ -8693,9 +8906,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) => {
@@ -8955,9 +9168,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: (0, import_uuid4.v4)()
     }));
   }
   static createBootstrapTransport(serviceInstanceId, role, endpoint) {
@@ -9201,7 +9414,7 @@ var CadenzaService = class {
       }
       for (const responder of responders) {
         const { task, descriptor } = responder;
-        const inquiryId = (0, import_uuid3.v4)();
+        const inquiryId = (0, import_uuid4.v4)();
         startTimeByTask.set(task, Date.now());
         const resolverTask = this.createEphemeralMetaTask(
           `Resolve inquiry ${inquiry} for ${descriptor.localTaskName}`,
@@ -9690,7 +9903,7 @@ var CadenzaService = class {
     this.bootstrap();
     this.validateName(serviceName);
     this.validateServiceName(serviceName);
-    const serviceId = options.customServiceId ?? (0, import_uuid3.v4)();
+    const serviceId = options.customServiceId ?? (0, import_uuid4.v4)();
     this.serviceRegistry.serviceName = serviceName;
     this.serviceRegistry.serviceInstanceId = serviceId;
     this.setHydrationResults(options.hydration);
@@ -10515,7 +10728,7 @@ CadenzaService.frontendSyncScheduled = false;
 var import_core5 = require("@cadenza.io/core");
 
 // src/ssr/createSSRInquiryBridge.ts
-var import_uuid4 = require("uuid");
+var import_uuid5 = require("uuid");
 function ensureFetch() {
   if (typeof globalThis.fetch !== "function") {
     throw new Error("SSR inquiry bridge requires global fetch support.");
@@ -10591,7 +10804,7 @@ function createSSRInquiryBridge(options = {}) {
         __remoteRoutineName: remoteRoutineName,
         __metadata: {
           ...context.__metadata ?? {},
-          __deputyExecId: (0, import_uuid4.v4)()
+          __deputyExecId: (0, import_uuid5.v4)()
         }
       }),
       signal