@cadenza.io/service 2.17.52 → 2.17.53

package/dist/index.mjs

@@ -385,16 +385,16 @@ function normalizeServiceTransportConfig(value) {
 }
 function normalizeServiceTransportDescriptor(value) {
   const raw = value ?? {};
-  const uuid9 = normalizeString(raw.uuid);
+  const uuid8 = normalizeString(raw.uuid);
   const serviceInstanceId = normalizeString(
     raw.serviceInstanceId ?? raw.service_instance_id
   );
   const config = normalizeServiceTransportConfig(raw);
-  if (!uuid9 || !serviceInstanceId || !config) {
+  if (!uuid8 || !serviceInstanceId || !config) {
     return null;
   }
   return {
-    uuid: uuid9,
+    uuid: uuid8,
     serviceInstanceId,
     role: config.role,
     origin: config.origin,
@@ -456,14 +456,14 @@ function normalizeTransportArray(value, serviceInstanceId) {
 }
 function normalizeServiceInstanceDescriptor(value) {
   const raw = value ?? {};
-  const uuid9 = normalizeString2(raw.uuid);
+  const uuid8 = normalizeString2(raw.uuid);
   const serviceName = normalizeString2(raw.serviceName ?? raw.service_name);
-  if (!uuid9 || !serviceName) {
+  if (!uuid8 || !serviceName) {
     return null;
   }
-  const transports = normalizeTransportArray(raw.transports, uuid9);
+  const transports = normalizeTransportArray(raw.transports, uuid8);
   return {
-    uuid: uuid9,
+    uuid: uuid8,
     serviceName,
     numberOfRunningGraphs: Math.max(
       0,
@@ -1104,15 +1104,15 @@ var ServiceRegistry = class _ServiceRegistry {
         if (!serviceInstance) {
           return false;
         }
-        const uuid9 = serviceInstance.uuid;
+        const uuid8 = serviceInstance.uuid;
         const serviceName = serviceInstance.serviceName;
         const deleted = Boolean(
           ctx.deleted ?? ctx.serviceInstance?.deleted ?? ctx.data?.deleted
         );
-        if (uuid9 === this.serviceInstanceId) return;
+        if (uuid8 === this.serviceInstanceId) return;
         if (deleted) {
-          const existingInstance = this.instances.get(serviceName)?.find((instance) => instance.uuid === uuid9);
-          const indexToDelete = this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid9) ?? -1;
+          const existingInstance = this.instances.get(serviceName)?.find((instance) => instance.uuid === uuid8);
+          const indexToDelete = this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid8) ?? -1;
           if (indexToDelete >= 0 && existingInstance) {
             this.instances.get(serviceName)?.splice(indexToDelete, 1);
             for (const transport of existingInstance.transports) {
@@ -1124,13 +1124,13 @@ var ServiceRegistry = class _ServiceRegistry {
           if (this.instances.get(serviceName)?.length === 0) {
             this.instances.delete(serviceName);
           }
-          this.unregisterDependee(uuid9, serviceName);
+          this.unregisterDependee(uuid8, serviceName);
           return;
         }
         if (!this.instances.has(serviceName))
           this.instances.set(serviceName, []);
         const instances = this.instances.get(serviceName);
-        const existing = instances.find((i) => i.uuid === uuid9);
+        const existing = instances.find((i) => i.uuid === uuid8);
         if (existing) {
           Object.assign(existing, {
             ...serviceInstance,
@@ -1140,7 +1140,7 @@ var ServiceRegistry = class _ServiceRegistry {
         } else {
           instances.push(serviceInstance);
         }
-        const trackedInstance = existing ?? instances.find((instance) => instance.uuid === uuid9);
+        const trackedInstance = existing ?? instances.find((instance) => instance.uuid === uuid8);
         if (trackedInstance) {
           const snapshot = this.resolveRuntimeStatusSnapshot(
             trackedInstance.numberOfRunningGraphs ?? 0,
@@ -1153,7 +1153,7 @@ var ServiceRegistry = class _ServiceRegistry {
           trackedInstance.reportedAt = trackedInstance.reportedAt ?? (/* @__PURE__ */ new Date()).toISOString();
         }
         if (!serviceInstance.isBootstrapPlaceholder) {
-          this.reconcileBootstrapPlaceholderInstance(serviceName, uuid9, emit);
+          this.reconcileBootstrapPlaceholderInstance(serviceName, uuid8, emit);
         }
         if (this.serviceName === serviceName) {
           return false;
@@ -1182,7 +1182,7 @@ var ServiceRegistry = class _ServiceRegistry {
             if (!clientCreated) {
               emit("meta.service_registry.dependee_registered", {
                 serviceName,
-                serviceInstanceId: uuid9,
+                serviceInstanceId: uuid8,
                 serviceTransportId: trackedTransport.uuid,
                 serviceOrigin: trackedTransport.origin,
                 transportProtocols: trackedTransport.protocols,
@@ -1196,7 +1196,7 @@ var ServiceRegistry = class _ServiceRegistry {
           } else {
             emit("meta.service_registry.routeable_transport_missing", {
               serviceName,
-              serviceInstanceId: uuid9,
+              serviceInstanceId: uuid8,
               requiredRole: this.getRoutingTransportRole(),
               isFrontend: this.isFrontend
             });
@@ -8616,13 +8616,12 @@ function tableFieldTypeToSchemaType(type) {
 }
 
 // src/Cadenza.ts
-import { v4 as uuid7 } from "uuid";
+import { v4 as uuid6 } from "uuid";
 
 // src/graph/controllers/GraphSyncController.ts
 import {
   META_ACTOR_SESSION_STATE_PERSIST_INTENT as META_ACTOR_SESSION_STATE_PERSIST_INTENT2
 } from "@cadenza.io/core";
-import { v4 as uuid6 } from "uuid";
 var ACTOR_TASK_METADATA = /* @__PURE__ */ Symbol.for("@cadenza.io/core/actor-task-meta");
 function getActorTaskRuntimeMetadata(taskFunction) {
   if (typeof taskFunction !== "function") {
@@ -8750,6 +8749,64 @@ function buildSyncInsertQueryData(ctx, queryData = {}) {
   }
   return nextQueryData;
 }
+function wireSyncTaskGraph(predecessorTask, graph, ...completionTasks) {
+  if (!graph) {
+    return void 0;
+  }
+  predecessorTask.then(graph.entryTask);
+  if (completionTasks.length > 0) {
+    graph.completionTask.then(...completionTasks);
+  }
+  return graph.completionTask;
+}
+function resolveLocalDatabaseTaskIntent(task, operation, tableName) {
+  if (!task) {
+    return void 0;
+  }
+  const expectedPrefix = `${operation}-pg-`;
+  const expectedSuffix = `-${tableName}`;
+  const handledIntents = Array.from(task.handlesIntents ?? []);
+  const directMatch = handledIntents.find(
+    (intent) => typeof intent === "string" && intent.startsWith(expectedPrefix) && intent.endsWith(expectedSuffix)
+  );
+  if (directMatch) {
+    return directMatch;
+  }
+  return handledIntents.find(
+    (intent) => typeof intent === "string" && intent.startsWith(expectedPrefix)
+  );
+}
+function createLocalDatabaseInquiryTask(localTask, operation, tableName, options = {}) {
+  const intentName = resolveLocalDatabaseTaskIntent(localTask, operation, tableName);
+  return CadenzaService.createMetaTask(
+    `Execute local graph sync ${operation} for ${tableName}`,
+    async (ctx, _emit, inquire) => {
+      if (!intentName) {
+        return {
+          ...ctx,
+          errored: true,
+          __success: false,
+          __error: `No local ${operation} intent found for ${tableName}`
+        };
+      }
+      const inquiryContext = {
+        ...ctx,
+        queryData: ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : {}
+      };
+      const result = await inquire(intentName, inquiryContext, {});
+      return {
+        ...ctx,
+        ...result
+      };
+    },
+    `Executes the local ${tableName} ${operation} operation through the generated database intent.`,
+    {
+      ...options,
+      register: false,
+      isHidden: true
+    }
+  );
+}
 function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, options = {}) {
   const localInsertTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName);
   const remoteInsertTask = isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(tableName, queryData, options) : void 0;
@@ -8757,7 +8814,7 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
   if (!localInsertTask && !remoteInsertTask) {
     return void 0;
   }
-  const targetTask = localInsertTask ?? remoteInsertTask;
+  const targetTask = localInsertTask ? createLocalDatabaseInquiryTask(localInsertTask, "insert", tableName, options) : remoteInsertTask;
   if (debugTable) {
     logSyncDebug("insert_task_resolved", {
       tableName,
@@ -8768,21 +8825,14 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
       options
     });
   }
-  const executionRequestedSignal = `meta.sync_controller.insert_execution_requested:${tableName}`;
-  const executionResolvedSignal = `meta.sync_controller.insert_execution_resolved:${tableName}`;
-  const executionFailedSignal = `meta.sync_controller.insert_execution_failed:${tableName}`;
-  const pendingResolverContexts = /* @__PURE__ */ new Map();
   const prepareExecutionTask = CadenzaService.createMetaTask(
     `Prepare graph sync insert for ${tableName}`,
     (ctx) => {
       const originalContext = { ...ctx };
-      const originalQueryData = buildSyncInsertQueryData(ctx, queryData);
-      if (typeof ctx.__resolverRequestId === "string") {
-        pendingResolverContexts.set(ctx.__resolverRequestId, {
-          originalContext,
-          originalQueryData
-        });
-      }
+      const originalQueryData = buildSyncInsertQueryData(
+        ctx,
+        queryData
+      );
       return {
         ...ctx,
         __resolverOriginalContext: originalContext,
@@ -8795,7 +8845,7 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
       register: false,
       isHidden: true
     }
-  ).doOn(executionRequestedSignal).emitsOnFail(executionFailedSignal);
+  );
   if (debugTable) {
     prepareExecutionTask.then(
       CadenzaService.createMetaTask(
@@ -8829,15 +8879,9 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
   }
   const finalizeExecutionTask = CadenzaService.createMetaTask(
     `Finalize graph sync insert for ${tableName}`,
-    (ctx, emit) => {
-      if (!ctx.__resolverRequestId) {
-        return false;
-      }
-      const pendingResolverContext = pendingResolverContexts.get(
-        ctx.__resolverRequestId
-      );
-      const originalContext = ctx.__resolverOriginalContext && typeof ctx.__resolverOriginalContext === "object" ? ctx.__resolverOriginalContext : pendingResolverContext?.originalContext ? { ...pendingResolverContext.originalContext } : {};
-      const originalQueryData = ctx.__resolverQueryData && typeof ctx.__resolverQueryData === "object" ? ctx.__resolverQueryData : pendingResolverContext?.originalQueryData;
+    (ctx) => {
+      const originalContext = ctx.__resolverOriginalContext && typeof ctx.__resolverOriginalContext === "object" ? ctx.__resolverOriginalContext : {};
+      const originalQueryData = ctx.__resolverQueryData && typeof ctx.__resolverQueryData === "object" ? ctx.__resolverQueryData : void 0;
       const normalizedContext = {
         ...originalContext,
         ...ctx,
@@ -8862,8 +8906,6 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
           });
         }
       }
-      pendingResolverContexts.delete(ctx.__resolverRequestId);
-      emit(executionResolvedSignal, normalizedContext);
       return normalizedContext;
     },
     `Finalizes ${tableName} graph-sync insert execution after the authority task finishes.`,
@@ -8872,95 +8914,12 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
       isHidden: true
     }
   );
-  targetTask.then(finalizeExecutionTask).emitsOnFail(executionFailedSignal);
   prepareExecutionTask.then(targetTask);
-  if (debugTable) {
-    CadenzaService.createMetaTask(
-      `Log failed graph sync insert execution for ${tableName}`,
-      (ctx) => {
-        if (tableName === "task") {
-          if (shouldDebugTaskSyncPayload(ctx) || shouldDebugSyncTaskName(ctx.__taskName)) {
-            logSyncDebug("insert_failed", {
-              tableName,
-              targetTaskName: targetTask.name,
-              payload: buildTaskSyncDebugPayload({
-                ...ctx,
-                __taskName: ctx.__taskName
-              })
-            });
-          }
-        } else {
-          logSyncDebug("insert_failed", {
-            tableName,
-            targetTaskName: targetTask.name,
-            ctx
-          });
-        }
-        if (typeof ctx.__resolverRequestId === "string") {
-          pendingResolverContexts.delete(ctx.__resolverRequestId);
-        }
-        return false;
-      },
-      `Logs failed ${tableName} sync insert executions.`,
-      {
-        register: false,
-        isHidden: true
-      }
-    ).doOn(executionFailedSignal);
-  }
-  return CadenzaService.createMetaTask(
-    `Resolve graph sync insert for ${tableName}`,
-    (ctx, emit) => new Promise((resolve) => {
-      const resolverRequestId = uuid6();
-      const resolvedContext = {
-        ...ctx,
-        __resolverRequestId: resolverRequestId
-      };
-      if (debugTable) {
-        if (tableName === "task") {
-          if (shouldDebugTaskSyncPayload(resolvedContext)) {
-            logSyncDebug("insert_resolver_request", {
-              tableName,
-              targetTaskName: targetTask.name,
-              payload: buildTaskSyncDebugPayload(resolvedContext)
-            });
-          }
-        } else {
-          logSyncDebug("insert_resolver_request", {
-            tableName,
-            targetTaskName: targetTask.name,
-            ctx: resolvedContext
-          });
-        }
-      }
-      CadenzaService.createEphemeralMetaTask(
-        `Resolve graph sync insert execution for ${tableName} (${resolverRequestId})`,
-        (resultCtx) => {
-          if (resultCtx.__resolverRequestId !== resolverRequestId) {
-            return false;
-          }
-          const normalizedResult = {
-            ...resultCtx
-          };
-          delete normalizedResult.__resolverRequestId;
-          pendingResolverContexts.delete(resolverRequestId);
-          resolve(normalizedResult);
-          return normalizedResult;
-        },
-        `Waits for ${tableName} graph-sync insert execution.`,
-        {
-          register: false
-        }
-      ).doOn(executionResolvedSignal, executionFailedSignal);
-      emit(executionRequestedSignal, resolvedContext);
-    }),
-    `Routes graph sync inserts for ${tableName} through the local authority task when available.`,
-    {
-      ...options,
-      register: false,
-      isHidden: true
-    }
-  );
+  targetTask.then(finalizeExecutionTask);
+  return {
+    entryTask: prepareExecutionTask,
+    completionTask: finalizeExecutionTask
+  };
 }
 var CADENZA_DB_REQUIRED_LOCAL_SYNC_INSERT_TABLES = [
   "intent_registry",
@@ -9121,8 +9080,8 @@ function resolveSyncQueryTask(isCadenzaDBReady, tableName, queryData = {}, optio
   if (!localQueryTask && !remoteQueryTask) {
     return void 0;
   }
-  const targetTask = localQueryTask ?? remoteQueryTask;
-  return CadenzaService.createMetaTask(
+  const targetTask = localQueryTask ? createLocalDatabaseInquiryTask(localQueryTask, "query", tableName, options) : remoteQueryTask;
+  const prepareQueryTask = CadenzaService.createMetaTask(
     `Prepare graph sync query for ${tableName}`,
     (ctx) => ({
       ...ctx,
@@ -9136,7 +9095,22 @@ function resolveSyncQueryTask(isCadenzaDBReady, tableName, queryData = {}, optio
       register: false,
       isHidden: true
     }
-  ).then(targetTask);
+  );
+  const finalizeQueryTask = CadenzaService.createMetaTask(
+    `Finalize graph sync query for ${tableName}`,
+    (ctx) => ctx,
+    `Finalizes ${tableName} graph-sync query payloads after authority lookup.`,
+    {
+      register: false,
+      isHidden: true
+    }
+  );
+  prepareQueryTask.then(targetTask);
+  targetTask.then(finalizeQueryTask);
+  return {
+    entryTask: prepareQueryTask,
+    completionTask: finalizeQueryTask
+  };
 }
 function getRegistrableTasks() {
   return Array.from(CadenzaService.registry.tasks.values()).filter(
@@ -9263,25 +9237,25 @@ var GraphSyncController = class _GraphSyncController {
       },
       { concurrency: 30 }
     );
-    const authoritativeTaskQueryTask = resolveSyncQueryTask(
+    const authoritativeTaskQueryGraph = resolveSyncQueryTask(
       this.isCadenzaDBReady,
       "task",
       {},
       { concurrency: 10 }
     );
-    const authoritativeRoutineQueryTask = resolveSyncQueryTask(
+    const authoritativeRoutineQueryGraph = resolveSyncQueryTask(
       this.isCadenzaDBReady,
       "routine",
       {},
       { concurrency: 10 }
     );
-    const authoritativeSignalQueryTask = resolveSyncQueryTask(
+    const authoritativeSignalQueryGraph = resolveSyncQueryTask(
       this.isCadenzaDBReady,
       "signal_registry",
       {},
       { concurrency: 10 }
     );
-    const authoritativeIntentQueryTask = resolveSyncQueryTask(
+    const authoritativeIntentQueryGraph = resolveSyncQueryTask(
       this.isCadenzaDBReady,
       "intent_registry",
       {},
@@ -9452,32 +9426,30 @@ var GraphSyncController = class _GraphSyncController {
         }
       }.bind(this)
     );
-    this.splitRoutinesTask.then(
-      resolveSyncInsertTask(
-        this.isCadenzaDBReady,
-        "routine",
-        {
-          onConflict: {
-            target: ["name", "version", "service_name"],
-            action: {
-              do: "nothing"
-            }
-          }
-        },
-        { concurrency: 30 }
-      )?.then(
-        CadenzaService.createMetaTask("Register routine", (ctx) => {
-          if (!didSyncInsertSucceed(ctx)) {
-            return;
+    const routineRegistrationGraph = resolveSyncInsertTask(
+      this.isCadenzaDBReady,
+      "routine",
+      {
+        onConflict: {
+          target: ["name", "version", "service_name"],
+          action: {
+            do: "nothing"
           }
-          CadenzaService.debounce("meta.sync_controller.synced_resource", {
-            delayMs: 3e3
-          });
-          CadenzaService.getRoutine(ctx.__routineName).registered = true;
-          return true;
-        }).then(gatherRoutineRegistrationTask)
-      )
+        }
+      },
+      { concurrency: 30 }
     );
+    const registerRoutineTask = CadenzaService.createMetaTask("Register routine", (ctx) => {
+      if (!didSyncInsertSucceed(ctx)) {
+        return;
+      }
+      CadenzaService.debounce("meta.sync_controller.synced_resource", {
+        delayMs: 3e3
+      });
+      CadenzaService.getRoutine(ctx.__routineName).registered = true;
+      return true;
+    }).then(gatherRoutineRegistrationTask);
+    wireSyncTaskGraph(this.splitRoutinesTask, routineRegistrationGraph, registerRoutineTask);
     this.splitTasksInRoutines = CadenzaService.createMetaTask(
       "Split tasks in routines",
       function* (ctx) {
@@ -9530,7 +9502,7 @@ var GraphSyncController = class _GraphSyncController {
         }
       }
     );
-    const registerTaskToRoutineMapTask = resolveSyncInsertTask(
+    const registerTaskToRoutineMapGraph = resolveSyncInsertTask(
       this.isCadenzaDBReady,
       "task_to_routine_map",
       {
@@ -9548,8 +9520,10 @@ var GraphSyncController = class _GraphSyncController {
         }
       },
       { concurrency: 30 }
-    )?.then(
-      CadenzaService.createMetaTask("Register routine task", (ctx) => {
+    );
+    const registerTaskToRoutineMapTask = CadenzaService.createMetaTask(
+      "Register routine task",
+      (ctx) => {
         if (!didSyncInsertSucceed(ctx)) {
           return;
         }
@@ -9559,11 +9533,13 @@ var GraphSyncController = class _GraphSyncController {
         CadenzaService.getRoutine(ctx.__routineName).registeredTasks.add(
           ctx.__taskName
         );
-      })
+      }
+    );
+    wireSyncTaskGraph(
+      this.splitTasksInRoutines,
+      registerTaskToRoutineMapGraph,
+      registerTaskToRoutineMapTask
     );
-    if (registerTaskToRoutineMapTask) {
-      this.splitTasksInRoutines.then(registerTaskToRoutineMapTask);
-    }
     this.splitSignalsTask = CadenzaService.createMetaTask(
       "Split signals for registration",
       function* (ctx) {
@@ -9592,30 +9568,35 @@ var GraphSyncController = class _GraphSyncController {
         }
       }.bind(this)
     );
-    this.splitSignalsTask.then(
-      resolveSyncInsertTask(
-        this.isCadenzaDBReady,
-        "signal_registry",
-        {
-          onConflict: {
-            target: ["name"],
-            action: {
-              do: "nothing"
-            }
-          }
-        },
-        { concurrency: 30 }
-      )?.then(
-        CadenzaService.createMetaTask("Process signal registration", (ctx) => {
-          if (!didSyncInsertSucceed(ctx)) {
-            return;
+    const signalRegistrationGraph = resolveSyncInsertTask(
+      this.isCadenzaDBReady,
+      "signal_registry",
+      {
+        onConflict: {
+          target: ["name"],
+          action: {
+            do: "nothing"
           }
-          CadenzaService.debounce("meta.sync_controller.synced_resource", {
-            delayMs: 3e3
-          });
-          return { signalName: ctx.__signal };
-        }).then(CadenzaService.signalBroker.registerSignalTask).then(gatherSignalRegistrationTask)
-      )
+        }
+      },
+      { concurrency: 30 }
+    );
+    const processSignalRegistrationTask = CadenzaService.createMetaTask(
+      "Process signal registration",
+      (ctx) => {
+        if (!didSyncInsertSucceed(ctx)) {
+          return;
+        }
+        CadenzaService.debounce("meta.sync_controller.synced_resource", {
+          delayMs: 3e3
+        });
+        return { signalName: ctx.__signal };
+      }
+    ).then(CadenzaService.signalBroker.registerSignalTask).then(gatherSignalRegistrationTask);
+    wireSyncTaskGraph(
+      this.splitSignalsTask,
+      signalRegistrationGraph,
+      processSignalRegistrationTask
     );
     this.splitTasksForRegistration = CadenzaService.createMetaTask(
       "Split tasks for registration",
@@ -9684,7 +9665,7 @@ var GraphSyncController = class _GraphSyncController {
         }
       }.bind(this)
     );
-    const registerTaskTask = resolveSyncInsertTask(
+    const registerTaskGraph = resolveSyncInsertTask(
       this.isCadenzaDBReady,
       "task",
       {
@@ -9696,8 +9677,10 @@ var GraphSyncController = class _GraphSyncController {
         }
       },
       { concurrency: 30 }
-    )?.then(
-      CadenzaService.createMetaTask("Record registration", (ctx, emit) => {
+    );
+    const registerTaskTask = CadenzaService.createMetaTask(
+      "Record registration",
+      (ctx, emit) => {
         if (shouldDebugSyncTaskName(ctx.__taskName)) {
           logSyncDebug("task_registration_result", {
             taskName: ctx.__taskName,
@@ -9717,11 +9700,9 @@ var GraphSyncController = class _GraphSyncController {
           task: CadenzaService.get(ctx.__taskName)
         });
         return true;
-      }).then(gatherTaskRegistrationTask)
-    );
-    if (registerTaskTask) {
-      this.splitTasksForRegistration.then(registerTaskTask);
-    }
+      }
+    ).then(gatherTaskRegistrationTask);
+    wireSyncTaskGraph(this.splitTasksForRegistration, registerTaskGraph, registerTaskTask);
     CadenzaService.createMetaTask(
       "Prepare created task for immediate sync",
       (ctx) => {
@@ -9780,31 +9761,37 @@ var GraphSyncController = class _GraphSyncController {
           };
         }
       }.bind(this)
-    ).then(
-      resolveSyncInsertTask(
-        this.isCadenzaDBReady,
-        "actor",
-        {
-          onConflict: {
-            target: ["name", "service_name", "version"],
-            action: {
-              do: "nothing"
-            }
-          }
-        },
-        { concurrency: 30 }
-      )?.then(
-        CadenzaService.createMetaTask("Record actor registration", (ctx) => {
-          if (!didSyncInsertSucceed(ctx)) {
-            return;
+    );
+    const actorRegistrationGraph = resolveSyncInsertTask(
+      this.isCadenzaDBReady,
+      "actor",
+      {
+        onConflict: {
+          target: ["name", "service_name", "version"],
+          action: {
+            do: "nothing"
           }
-          CadenzaService.debounce("meta.sync_controller.synced_resource", {
-            delayMs: 3e3
-          });
-          this.registeredActors.add(ctx.__actorRegistrationKey);
-          return true;
-        }).then(gatherActorRegistrationTask)
-      )
+        }
+      },
+      { concurrency: 30 }
+    );
+    const recordActorRegistrationTask = CadenzaService.createMetaTask(
+      "Record actor registration",
+      (ctx) => {
+        if (!didSyncInsertSucceed(ctx)) {
+          return;
+        }
+        CadenzaService.debounce("meta.sync_controller.synced_resource", {
+          delayMs: 3e3
+        });
+        this.registeredActors.add(ctx.__actorRegistrationKey);
+        return true;
+      }
+    ).then(gatherActorRegistrationTask);
+    wireSyncTaskGraph(
+      this.splitActorsForRegistration,
+      actorRegistrationGraph,
+      recordActorRegistrationTask
     );
     this.registerActorTaskMapTask = CadenzaService.createMetaTask(
       "Split actor task maps",
@@ -9842,36 +9829,42 @@ var GraphSyncController = class _GraphSyncController {
           __actorTaskMapRegistrationKey: registrationKey
         };
       }.bind(this)
-    ).then(
-      resolveSyncInsertTask(
-        this.isCadenzaDBReady,
-        "actor_task_map",
-        {
-          onConflict: {
-            target: [
-              "actor_name",
-              "actor_version",
-              "task_name",
-              "task_version",
-              "service_name"
-            ],
-            action: {
-              do: "nothing"
-            }
-          }
-        },
-        { concurrency: 30 }
-      )?.then(
-        CadenzaService.createMetaTask("Record actor task map registration", (ctx) => {
-          if (!didSyncInsertSucceed(ctx)) {
-            return;
+    );
+    const actorTaskMapRegistrationGraph = resolveSyncInsertTask(
+      this.isCadenzaDBReady,
+      "actor_task_map",
+      {
+        onConflict: {
+          target: [
+            "actor_name",
+            "actor_version",
+            "task_name",
+            "task_version",
+            "service_name"
+          ],
+          action: {
+            do: "nothing"
           }
-          CadenzaService.debounce("meta.sync_controller.synced_resource", {
-            delayMs: 3e3
-          });
-          this.registeredActorTaskMaps.add(ctx.__actorTaskMapRegistrationKey);
-        })
-      )
+        }
+      },
+      { concurrency: 30 }
+    );
+    const recordActorTaskMapRegistrationTask = CadenzaService.createMetaTask(
+      "Record actor task map registration",
+      (ctx) => {
+        if (!didSyncInsertSucceed(ctx)) {
+          return;
+        }
+        CadenzaService.debounce("meta.sync_controller.synced_resource", {
+          delayMs: 3e3
+        });
+        this.registeredActorTaskMaps.add(ctx.__actorTaskMapRegistrationKey);
+      }
+    );
+    wireSyncTaskGraph(
+      this.registerActorTaskMapTask,
+      actorTaskMapRegistrationGraph,
+      recordActorTaskMapRegistrationTask
     );
     const registerSignalTask = CadenzaService.createMetaTask(
       "Record signal registration",
@@ -9930,25 +9923,32 @@ var GraphSyncController = class _GraphSyncController {
         return emittedCount > 0;
       }
     );
-    CadenzaService.createMetaTask("Process split signal-to-task map", (ctx) => ctx).doOn("meta.sync_controller.signal_task_map_split").then(
-      resolveSyncInsertTask(
-        this.isCadenzaDBReady,
-        "signal_to_task_map",
-        {
-          onConflict: {
-            target: [
-              "task_name",
-              "task_version",
-              "service_name",
-              "signal_name"
-            ],
-            action: {
-              do: "nothing"
-            }
+    const processSplitSignalToTaskMapTask = CadenzaService.createMetaTask(
+      "Process split signal-to-task map",
+      (ctx) => ctx
+    ).doOn("meta.sync_controller.signal_task_map_split");
+    const signalToTaskMapGraph = resolveSyncInsertTask(
+      this.isCadenzaDBReady,
+      "signal_to_task_map",
+      {
+        onConflict: {
+          target: [
+            "task_name",
+            "task_version",
+            "service_name",
+            "signal_name"
+          ],
+          action: {
+            do: "nothing"
           }
-        },
-        { concurrency: 30 }
-      )?.then(registerSignalTask)
+        }
+      },
+      { concurrency: 30 }
+    );
+    wireSyncTaskGraph(
+      processSplitSignalToTaskMapTask,
+      signalToTaskMapGraph,
+      registerSignalTask
     );
     this.splitIntentsTask = CadenzaService.createMetaTask(
       "Split intents for registration",
@@ -9974,19 +9974,23 @@ var GraphSyncController = class _GraphSyncController {
         }
       }.bind(this)
     );
-    this.splitIntentsTask.then(
-      insertIntentRegistryTask?.then(
-        CadenzaService.createMetaTask("Record intent definition registration", (ctx) => {
-          if (!didSyncInsertSucceed(ctx)) {
-            return;
-          }
-          CadenzaService.debounce("meta.sync_controller.synced_resource", {
-            delayMs: 3e3
-          });
-          this.registeredIntentDefinitions.add(ctx.__intentName);
-          return true;
-        }).then(gatherIntentRegistrationTask)
-      )
+    const recordIntentDefinitionRegistrationTask = CadenzaService.createMetaTask(
+      "Record intent definition registration",
+      (ctx) => {
+        if (!didSyncInsertSucceed(ctx)) {
+          return;
+        }
+        CadenzaService.debounce("meta.sync_controller.synced_resource", {
+          delayMs: 3e3
+        });
+        this.registeredIntentDefinitions.add(ctx.__intentName);
+        return true;
+      }
+    ).then(gatherIntentRegistrationTask);
+    wireSyncTaskGraph(
+      this.splitIntentsTask,
+      insertIntentRegistryTask,
+      recordIntentDefinitionRegistrationTask
     );
     const registerIntentTask = CadenzaService.createMetaTask(
       "Record intent registration",
@@ -10068,67 +10072,82 @@ var GraphSyncController = class _GraphSyncController {
         return true;
       }.bind(this)
     );
-    CadenzaService.createMetaTask("Process split intent-to-task map", (ctx) => ctx).doOn("meta.sync_controller.intent_task_map_split").then(
-      CadenzaService.createMetaTask(
-        "Prepare intent definition for intent-to-task map",
-        (ctx) => {
-          if (!ctx.__intentDefinition || !ctx.__intentMapData) {
-            return false;
-          }
-          if (shouldDebugSyncTaskName(ctx.__taskName) || shouldDebugSyncIntentName(ctx.__intent)) {
-            logSyncDebug("intent_definition_prepare", {
-              taskName: ctx.__taskName,
-              intentName: ctx.__intent,
-              intentDefinition: ctx.__intentDefinition
-            });
+    const processSplitIntentToTaskMapTask = CadenzaService.createMetaTask(
+      "Process split intent-to-task map",
+      (ctx) => ctx
+    ).doOn("meta.sync_controller.intent_task_map_split");
+    const prepareIntentDefinitionForIntentMapTask = CadenzaService.createMetaTask(
+      "Prepare intent definition for intent-to-task map",
+      (ctx) => {
+        if (!ctx.__intentDefinition || !ctx.__intentMapData) {
+          return false;
+        }
+        if (shouldDebugSyncTaskName(ctx.__taskName) || shouldDebugSyncIntentName(ctx.__intent)) {
+          logSyncDebug("intent_definition_prepare", {
+            taskName: ctx.__taskName,
+            intentName: ctx.__intent,
+            intentDefinition: ctx.__intentDefinition
+          });
+        }
+        return {
+          ...ctx,
+          data: ctx.__intentDefinition
+        };
+      }
+    );
+    const restoreIntentToTaskMapPayloadTask = CadenzaService.createMetaTask(
+      "Restore intent-to-task map payload",
+      (ctx) => {
+        if (!ctx.__intentMapData) {
+          return false;
+        }
+        if (shouldDebugSyncTaskName(ctx.__taskName) || shouldDebugSyncIntentName(ctx.__intent)) {
+          logSyncDebug("intent_map_payload_restore", {
+            taskName: ctx.__taskName,
+            intentName: ctx.__intent,
+            intentMapData: ctx.__intentMapData
+          });
+        }
+        return {
+          ...ctx,
+          data: ctx.__intentMapData
+        };
+      }
+    );
+    const intentToTaskMapGraph = resolveSyncInsertTask(
+      this.isCadenzaDBReady,
+      "intent_to_task_map",
+      {
+        onConflict: {
+          target: [
+            "intent_name",
+            "task_name",
+            "task_version",
+            "service_name"
+          ],
+          action: {
+            do: "nothing"
           }
-          return {
-            ...ctx,
-            data: ctx.__intentDefinition
-          };
         }
-      ).then(
-        ensureIntentRegistryBeforeIntentMapTask?.then(
-          CadenzaService.createMetaTask(
-            "Restore intent-to-task map payload",
-            (ctx) => {
-              if (!ctx.__intentMapData) {
-                return false;
-              }
-              if (shouldDebugSyncTaskName(ctx.__taskName) || shouldDebugSyncIntentName(ctx.__intent)) {
-                logSyncDebug("intent_map_payload_restore", {
-                  taskName: ctx.__taskName,
-                  intentName: ctx.__intent,
-                  intentMapData: ctx.__intentMapData
-                });
-              }
-              return {
-                ...ctx,
-                data: ctx.__intentMapData
-              };
-            }
-          ).then(
-            resolveSyncInsertTask(
-              this.isCadenzaDBReady,
-              "intent_to_task_map",
-              {
-                onConflict: {
-                  target: [
-                    "intent_name",
-                    "task_name",
-                    "task_version",
-                    "service_name"
-                  ],
-                  action: {
-                    do: "nothing"
-                  }
-                }
-              },
-              { concurrency: 30 }
-            )?.then(registerIntentTask)
-          )
-        )
-      )
+      },
+      { concurrency: 30 }
+    );
+    processSplitIntentToTaskMapTask.then(prepareIntentDefinitionForIntentMapTask);
+    if (ensureIntentRegistryBeforeIntentMapTask) {
+      wireSyncTaskGraph(
+        prepareIntentDefinitionForIntentMapTask,
+        ensureIntentRegistryBeforeIntentMapTask,
+        restoreIntentToTaskMapPayloadTask
+      );
+    } else {
+      prepareIntentDefinitionForIntentMapTask.then(
+        restoreIntentToTaskMapPayloadTask
+      );
+    }
+    wireSyncTaskGraph(
+      restoreIntentToTaskMapPayloadTask,
+      intentToTaskMapGraph,
+      registerIntentTask
     );
     this.registerTaskMapTask = CadenzaService.createMetaTask(
       "Register task map to DB",
@@ -10164,39 +10183,45 @@ var GraphSyncController = class _GraphSyncController {
           };
         }
       }
-    ).then(
-      resolveSyncInsertTask(
-        this.isCadenzaDBReady,
-        "directional_task_graph_map",
-        {
-          onConflict: {
-            target: [
-              "task_name",
-              "predecessor_task_name",
-              "task_version",
-              "predecessor_task_version",
-              "service_name",
-              "predecessor_service_name"
-            ],
-            action: {
-              do: "nothing"
-            }
-          }
-        },
-        { concurrency: 30 }
-      )?.then(
-        CadenzaService.createMetaTask("Record task map registration", (ctx) => {
-          if (!didSyncInsertSucceed(ctx)) {
-            return;
+    );
+    const taskMapRegistrationGraph = resolveSyncInsertTask(
+      this.isCadenzaDBReady,
+      "directional_task_graph_map",
+      {
+        onConflict: {
+          target: [
+            "task_name",
+            "predecessor_task_name",
+            "task_version",
+            "predecessor_task_version",
+            "service_name",
+            "predecessor_service_name"
+          ],
+          action: {
+            do: "nothing"
           }
-          CadenzaService.debounce("meta.sync_controller.synced_resource", {
-            delayMs: 3e3
-          });
-          CadenzaService.get(ctx.__taskName)?.taskMapRegistration.add(
-            ctx.__nextTaskName
-          );
-        })
-      )
+        }
+      },
+      { concurrency: 30 }
+    );
+    const recordTaskMapRegistrationTask = CadenzaService.createMetaTask(
+      "Record task map registration",
+      (ctx) => {
+        if (!didSyncInsertSucceed(ctx)) {
+          return;
+        }
+        CadenzaService.debounce("meta.sync_controller.synced_resource", {
+          delayMs: 3e3
+        });
+        CadenzaService.get(ctx.__taskName)?.taskMapRegistration.add(
+          ctx.__nextTaskName
+        );
+      }
+    );
+    wireSyncTaskGraph(
+      this.registerTaskMapTask,
+      taskMapRegistrationGraph,
+      recordTaskMapRegistrationTask
     );
     this.registerDeputyRelationshipTask = CadenzaService.createMetaTask(
       "Register deputy relationship",
@@ -10223,40 +10248,43 @@ var GraphSyncController = class _GraphSyncController {
           };
         }
       }
-    ).then(
-      resolveSyncInsertTask(
-        this.isCadenzaDBReady,
-        "directional_task_graph_map",
-        {
-          onConflict: {
-            target: [
-              "task_name",
-              "predecessor_task_name",
-              "task_version",
-              "predecessor_task_version",
-              "service_name",
-              "predecessor_service_name"
-            ],
-            action: {
-              do: "nothing"
-            }
-          }
-        },
-        { concurrency: 30 }
-      )?.then(
-        CadenzaService.createMetaTask(
-          "Record deputy relationship registration",
-          (ctx) => {
-            if (!didSyncInsertSucceed(ctx)) {
-              return;
-            }
-            CadenzaService.debounce("meta.sync_controller.synced_resource", {
-              delayMs: 3e3
-            });
-            CadenzaService.get(ctx.__taskName).registeredDeputyMap = true;
+    );
+    const deputyRelationshipRegistrationGraph = resolveSyncInsertTask(
+      this.isCadenzaDBReady,
+      "directional_task_graph_map",
+      {
+        onConflict: {
+          target: [
+            "task_name",
+            "predecessor_task_name",
+            "task_version",
+            "predecessor_task_version",
+            "service_name",
+            "predecessor_service_name"
+          ],
+          action: {
+            do: "nothing"
           }
-        )
-      )
+        }
+      },
+      { concurrency: 30 }
+    );
+    const recordDeputyRelationshipRegistrationTask = CadenzaService.createMetaTask(
+      "Record deputy relationship registration",
+      (ctx) => {
+        if (!didSyncInsertSucceed(ctx)) {
+          return;
+        }
+        CadenzaService.debounce("meta.sync_controller.synced_resource", {
+          delayMs: 3e3
+        });
+        CadenzaService.get(ctx.__taskName).registeredDeputyMap = true;
+      }
+    );
+    wireSyncTaskGraph(
+      this.registerDeputyRelationshipTask,
+      deputyRelationshipRegistrationGraph,
+      recordDeputyRelationshipRegistrationTask
     );
     const reconcileTaskRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
       "Reconcile task registration from authority",
@@ -10388,7 +10416,7 @@ var GraphSyncController = class _GraphSyncController {
         isHidden: true
       }
     );
-    const authoritativeTaskReconciliationGraph = authoritativeTaskQueryTask?.then(reconcileTaskRegistrationFromAuthorityTask) ?? CadenzaService.createMetaTask(
+    const skipAuthoritativeTaskReconciliationTask = CadenzaService.createMetaTask(
       "Skip authoritative task reconciliation",
       () => false,
       "Skips task reconciliation when no authority query task is available.",
@@ -10397,7 +10425,7 @@ var GraphSyncController = class _GraphSyncController {
         isHidden: true
       }
     );
-    const authoritativeRoutineReconciliationGraph = authoritativeRoutineQueryTask?.then(reconcileRoutineRegistrationFromAuthorityTask) ?? CadenzaService.createMetaTask(
+    const skipAuthoritativeRoutineReconciliationTask = CadenzaService.createMetaTask(
       "Skip authoritative routine reconciliation",
       () => false,
       "Skips routine reconciliation when no authority query task is available.",
@@ -10406,7 +10434,7 @@ var GraphSyncController = class _GraphSyncController {
         isHidden: true
       }
     );
-    const authoritativeSignalReconciliationGraph = authoritativeSignalQueryTask?.then(reconcileSignalRegistrationFromAuthorityTask) ?? CadenzaService.createMetaTask(
+    const skipAuthoritativeSignalReconciliationTask = CadenzaService.createMetaTask(
       "Skip authoritative signal reconciliation",
       () => false,
       "Skips signal reconciliation when no authority query task is available.",
@@ -10415,7 +10443,7 @@ var GraphSyncController = class _GraphSyncController {
         isHidden: true
       }
     );
-    const authoritativeIntentReconciliationGraph = authoritativeIntentQueryTask?.then(reconcileIntentRegistrationFromAuthorityTask) ?? CadenzaService.createMetaTask(
+    const skipAuthoritativeIntentReconciliationTask = CadenzaService.createMetaTask(
       "Skip authoritative intent reconciliation",
       () => false,
       "Skips intent reconciliation when no authority query task is available.",
@@ -10424,6 +10452,26 @@ var GraphSyncController = class _GraphSyncController {
         isHidden: true
       }
     );
+    if (authoritativeTaskQueryGraph) {
+      authoritativeTaskQueryGraph.completionTask.then(
+        reconcileTaskRegistrationFromAuthorityTask
+      );
+    }
+    if (authoritativeRoutineQueryGraph) {
+      authoritativeRoutineQueryGraph.completionTask.then(
+        reconcileRoutineRegistrationFromAuthorityTask
+      );
+    }
+    if (authoritativeSignalQueryGraph) {
+      authoritativeSignalQueryGraph.completionTask.then(
+        reconcileSignalRegistrationFromAuthorityTask
+      );
+    }
+    if (authoritativeIntentQueryGraph) {
+      authoritativeIntentQueryGraph.completionTask.then(
+        reconcileIntentRegistrationFromAuthorityTask
+      );
+    }
     const authoritativeRegistrationTriggers = [
       "meta.service_registry.initial_sync_complete",
       "meta.sync_requested",
@@ -10456,7 +10504,9 @@ var GraphSyncController = class _GraphSyncController {
         register: false,
         isHidden: true
       }
-    ).doOn(...authoritativeRegistrationTriggers).then(authoritativeTaskReconciliationGraph);
+    ).doOn(...authoritativeRegistrationTriggers).then(
+      authoritativeTaskQueryGraph?.entryTask ?? skipAuthoritativeTaskReconciliationTask
+    );
     CadenzaService.createMetaTask(
       "Prepare authoritative routine registration query",
       (ctx) => {
@@ -10483,7 +10533,9 @@ var GraphSyncController = class _GraphSyncController {
         register: false,
         isHidden: true
       }
-    ).doOn(...authoritativeRegistrationTriggers).then(authoritativeRoutineReconciliationGraph);
+    ).doOn(...authoritativeRegistrationTriggers).then(
+      authoritativeRoutineQueryGraph?.entryTask ?? skipAuthoritativeRoutineReconciliationTask
+    );
     CadenzaService.createMetaTask(
       "Prepare authoritative signal registration query",
       (ctx) => {
@@ -10502,7 +10554,9 @@ var GraphSyncController = class _GraphSyncController {
         register: false,
         isHidden: true
       }
-    ).doOn(...authoritativeRegistrationTriggers).then(authoritativeSignalReconciliationGraph);
+    ).doOn(...authoritativeRegistrationTriggers).then(
+      authoritativeSignalQueryGraph?.entryTask ?? skipAuthoritativeSignalReconciliationTask
+    );
     CadenzaService.createMetaTask(
       "Prepare authoritative intent registration query",
       (ctx) => {
@@ -10521,7 +10575,9 @@ var GraphSyncController = class _GraphSyncController {
         register: false,
         isHidden: true
       }
-    ).doOn(...authoritativeRegistrationTriggers).then(authoritativeIntentReconciliationGraph);
+    ).doOn(...authoritativeRegistrationTriggers).then(
+      authoritativeIntentQueryGraph?.entryTask ?? skipAuthoritativeIntentReconciliationTask
+    );
     CadenzaService.signalBroker.getSignalsTask.clone().doOn(
       "meta.sync_controller.sync_tick",
       "meta.service_registry.initial_sync_complete",
@@ -10956,7 +11012,7 @@ var CadenzaService = class {
     ).map((transport) => ({
       ...transport,
       protocols: transport.protocols && transport.protocols.length > 0 ? transport.protocols : useSocket ? ["rest", "socket"] : ["rest"],
-      uuid: uuid7()
+      uuid: uuid6()
     }));
   }
   static createBootstrapTransport(serviceInstanceId, role, endpoint) {
@@ -11208,7 +11264,7 @@ var CadenzaService = class {
       }
       for (const responder of responders) {
         const { task, descriptor } = responder;
-        const inquiryId = uuid7();
+        const inquiryId = uuid6();
         startTimeByTask.set(task, Date.now());
         const resolverTask = this.createEphemeralMetaTask(
           `Resolve inquiry ${inquiry} for ${descriptor.localTaskName}`,
@@ -11716,7 +11772,7 @@ var CadenzaService = class {
     this.bootstrap();
     this.validateName(serviceName);
     this.validateServiceName(serviceName);
-    const serviceId = options.customServiceId ?? uuid7();
+    const serviceId = options.customServiceId ?? uuid6();
     this.serviceRegistry.serviceName = serviceName;
     this.serviceRegistry.serviceInstanceId = serviceId;
     this.setHydrationResults(options.hydration);
@@ -12567,7 +12623,7 @@ import {
 } from "@cadenza.io/core";
 
 // src/ssr/createSSRInquiryBridge.ts
-import { v4 as uuid8 } from "uuid";
+import { v4 as uuid7 } from "uuid";
 function ensureFetch() {
   if (typeof globalThis.fetch !== "function") {
     throw new Error("SSR inquiry bridge requires global fetch support.");
@@ -12656,7 +12712,7 @@ function createSSRInquiryBridge(options = {}) {
         __remoteRoutineName: remoteRoutineName,
         __metadata: {
           ...context.__metadata ?? {},
-          __deputyExecId: uuid8()
+          __deputyExecId: uuid7()
         }
       }),
       signal