@cadenza.io/service 2.17.23 → 2.17.25

package/dist/index.mjs

@@ -686,6 +686,72 @@ var INTERNAL_RUNTIME_STATUS_TASK_NAMES = /* @__PURE__ */ new Set([
   "Collect distributed readiness",
   "Get status"
 ]);
+function buildServiceRegistryInsertQueryData(ctx, queryData) {
+  const joinedContexts = Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : [];
+  const getJoinedValue = (key) => {
+    for (let index = joinedContexts.length - 1; index >= 0; index -= 1) {
+      const joinedContext = joinedContexts[index];
+      if (joinedContext && typeof joinedContext === "object" && (Object.prototype.hasOwnProperty.call(joinedContext, key) || joinedContext[key] !== void 0)) {
+        return joinedContext[key];
+      }
+    }
+    return void 0;
+  };
+  const registrationData = Object.prototype.hasOwnProperty.call(ctx, "__registrationData") && ctx.__registrationData !== void 0 ? ctx.__registrationData : getJoinedValue("__registrationData");
+  const existingQueryData = ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : {};
+  const nextQueryData = {
+    ...existingQueryData,
+    ...queryData
+  };
+  const resolvedData = Object.prototype.hasOwnProperty.call(ctx, "data") || ctx.data !== void 0 ? ctx.data : getJoinedValue("data");
+  const resolvedBatch = Object.prototype.hasOwnProperty.call(ctx, "batch") || ctx.batch !== void 0 ? ctx.batch : getJoinedValue("batch");
+  if (!("data" in nextQueryData) && (resolvedData !== void 0 || registrationData !== void 0)) {
+    nextQueryData.data = resolvedData !== void 0 ? resolvedData && typeof resolvedData === "object" ? { ...resolvedData } : resolvedData : registrationData && typeof registrationData === "object" && !Array.isArray(registrationData) ? { ...registrationData } : registrationData;
+  }
+  if (!("batch" in nextQueryData) && resolvedBatch !== void 0) {
+    nextQueryData.batch = Array.isArray(resolvedBatch) ? resolvedBatch.map(
+      (row) => row && typeof row === "object" ? { ...row } : row
+    ) : resolvedBatch;
+  }
+  return nextQueryData;
+}
+function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {}) {
+  const remoteInsertTask = CadenzaService.createCadenzaDBInsertTask(
+    tableName,
+    queryData,
+    options
+  );
+  return CadenzaService.createUniqueMetaTask(
+    `Resolve service registry insert for ${tableName}`,
+    (ctx, emit, inquire, progressCallback) => {
+      const nextQueryData = buildServiceRegistryInsertQueryData(ctx, queryData);
+      if (tableName === "service" && nextQueryData.data === void 0) {
+        CadenzaService.log(
+          "Service registry insert resolver missing service payload.",
+          {
+            ctxKeys: ctx && typeof ctx === "object" ? Object.keys(ctx).sort() : [],
+            hasData: !!ctx && typeof ctx === "object" && (Object.prototype.hasOwnProperty.call(ctx, "data") || ctx.data !== void 0),
+            hasRegistrationData: !!ctx && typeof ctx === "object" && (Object.prototype.hasOwnProperty.call(ctx, "__registrationData") || ctx.__registrationData !== void 0),
+            serviceName: ctx?.__serviceName ?? ctx?.data?.name ?? null
+          },
+          "warning"
+        );
+      }
+      const targetTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName) ?? remoteInsertTask;
+      return targetTask.taskFunction(
+        {
+          ...ctx,
+          queryData: nextQueryData
+        },
+        emit,
+        inquire,
+        progressCallback
+      );
+    },
+    `Resolves ${tableName} inserts through the local CadenzaDB task when available.`,
+    options
+  );
+}
 function readPositiveIntegerEnv(name, fallback) {
   if (typeof process === "undefined") {
     return fallback;
@@ -1896,7 +1962,7 @@ var ServiceRegistry = class _ServiceRegistry {
       },
       "Collects distributed transport diagnostics using inquiry responders."
     ).doOn("meta.service_registry.transport_diagnostics_requested").emits("meta.service_registry.transport_diagnostics_collected").emitsOnFail("meta.service_registry.transport_diagnostics_failed");
-    this.insertServiceTask = CadenzaService.createCadenzaDBInsertTask(
+    this.insertServiceTask = resolveServiceRegistryInsertTask(
       "service",
       {
         onConflict: {
@@ -1947,7 +2013,7 @@ var ServiceRegistry = class _ServiceRegistry {
         retryDelayFactor: 1.3
       }
     ).emits("meta.service_registry.service_inserted").emitsOnFail("meta.service_registry.service_insertion_failed");
-    this.insertServiceInstanceTask = CadenzaService.createCadenzaDBInsertTask(
+    this.insertServiceInstanceTask = resolveServiceRegistryInsertTask(
       "service_instance",
       {},
       {
@@ -2005,7 +2071,7 @@ var ServiceRegistry = class _ServiceRegistry {
         retryCount: 5,
         retryDelay: 1e3
       }
-    ).doOn("meta.service_registry.instance_registration_requested").then(
+    ).then(
       CadenzaService.createMetaTask(
         "Setup service",
         (ctx) => {
@@ -2032,8 +2098,17 @@ var ServiceRegistry = class _ServiceRegistry {
           this.useSocket = __useSocket;
           this.retryCount = __retryCount;
           this.isFrontend = typeof __isFrontend === "boolean" ? __isFrontend : !!normalizedLocalInstance.isFrontend;
-          console.log("SETUP SERVICE", this.serviceInstanceId);
-          return true;
+          return {
+            ...ctx,
+            serviceInstance: normalizedLocalInstance,
+            data: {
+              ...ctx.data ?? {},
+              uuid: normalizedLocalInstance.uuid,
+              service_name: normalizedLocalInstance.serviceName
+            },
+            __serviceName: normalizedLocalInstance.serviceName,
+            __serviceInstanceId: normalizedLocalInstance.uuid
+          };
         },
         "Sets service instance id after insertion"
       ).emits("meta.service_registry.instance_inserted").then(
@@ -2047,6 +2122,10 @@ var ServiceRegistry = class _ServiceRegistry {
                 data: {
                   ...transport,
                   service_instance_id: transport.service_instance_id ?? ctx.__serviceInstanceId
+                },
+                __registrationData: {
+                  ...transport,
+                  service_instance_id: transport.service_instance_id ?? ctx.__serviceInstanceId
                 }
               };
               emit(
@@ -2060,7 +2139,25 @@ var ServiceRegistry = class _ServiceRegistry {
         ).attachSignal("meta.service_registry.transport_registration_requested")
       )
     );
-    this.insertServiceTransportTask = CadenzaService.createCadenzaDBInsertTask(
+    CadenzaService.createMetaTask(
+      "Prepare service instance registration",
+      (ctx) => {
+        const serviceName = String(
+          ctx.data?.service_name ?? ctx.__serviceName ?? this.serviceName ?? ""
+        ).trim();
+        if (serviceName === "CadenzaDB" && !CadenzaService.getLocalCadenzaDBInsertTask("service_instance")) {
+          CadenzaService.schedule(
+            "meta.service_registry.instance_registration_requested",
+            { ...ctx },
+            250
+          );
+          return false;
+        }
+        return ctx;
+      },
+      "Waits for the exact local CadenzaDB service instance insert task during self-bootstrap."
+    ).doOn("meta.service_registry.instance_registration_requested").then(this.insertServiceInstanceTask);
+    this.insertServiceTransportTask = resolveServiceRegistryInsertTask(
       "service_instance_transport",
       {
         onConflict: {
@@ -2125,7 +2222,25 @@ var ServiceRegistry = class _ServiceRegistry {
         retryCount: 5,
         retryDelay: 1e3
       }
-    ).doOn("meta.service_registry.transport_registration_requested").emits("meta.service_registry.transport_registered").emitsOnFail("meta.service_registry.transport_registration_failed");
+    ).emits("meta.service_registry.transport_registered").emitsOnFail("meta.service_registry.transport_registration_failed");
+    CadenzaService.createMetaTask(
+      "Prepare service transport registration",
+      (ctx) => {
+        const serviceName = String(
+          ctx.__serviceName ?? this.serviceName ?? ""
+        ).trim();
+        if (serviceName === "CadenzaDB" && !CadenzaService.getLocalCadenzaDBInsertTask("service_instance_transport")) {
+          CadenzaService.schedule(
+            "meta.service_registry.transport_registration_requested",
+            { ...ctx },
+            250
+          );
+          return false;
+        }
+        return ctx;
+      },
+      "Waits for the exact local CadenzaDB service transport insert task during self-bootstrap."
+    ).doOn("meta.service_registry.transport_registration_requested").then(this.insertServiceTransportTask);
     CadenzaService.createMetaTask(
       "Handle service creation",
       (ctx) => {
@@ -3395,6 +3510,16 @@ var RestController = class _RestController {
                   is_blocked: false,
                   health: {}
                 },
+                __registrationData: {
+                  uuid: ctx.__serviceInstanceId,
+                  process_pid: 1,
+                  service_name: ctx.__serviceName,
+                  is_frontend: true,
+                  is_active: true,
+                  is_non_responsive: false,
+                  is_blocked: false,
+                  health: {}
+                },
                 __transportData: [],
                 ...ctx
               });
@@ -3694,6 +3819,9 @@ var RestController = class _RestController {
                   is_blocked: false,
                   health: {}
                 };
+                ctx.__registrationData = {
+                  ...ctx.data
+                };
                 ctx.__transportData = transportData;
                 delete ctx.__app;
                 CadenzaService.emit(
@@ -8102,12 +8230,6 @@ import { v4 as uuid5 } from "uuid";
 
 // src/graph/controllers/GraphSyncController.ts
 var ACTOR_TASK_METADATA = /* @__PURE__ */ Symbol.for("@cadenza.io/core/actor-task-meta");
-var LOCAL_SYNC_QUERY_DATA = /* @__PURE__ */ Symbol.for(
-  "@cadenza.io/service/local-sync-query-data"
-);
-var LOCAL_SYNC_ORIGINAL_TASK_FUNCTION = /* @__PURE__ */ Symbol.for(
-  "@cadenza.io/service/local-sync-original-task-function"
-);
 function getActorTaskRuntimeMetadata(taskFunction) {
   if (typeof taskFunction !== "function") {
     return void 0;
@@ -8184,38 +8306,71 @@ function buildIntentRegistryData(intent) {
     isMeta: isMetaIntentName(name)
   };
 }
+function getJoinedContextValue(ctx, key) {
+  const joinedContexts = Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : [];
+  for (let index = joinedContexts.length - 1; index >= 0; index -= 1) {
+    const joinedContext = joinedContexts[index];
+    if (joinedContext && typeof joinedContext === "object" && (Object.prototype.hasOwnProperty.call(joinedContext, key) || joinedContext[key] !== void 0)) {
+      return joinedContext[key];
+    }
+  }
+  return void 0;
+}
+function didSyncInsertSucceed(ctx) {
+  return !ctx.errored && ctx.__success !== false;
+}
+function buildSyncInsertQueryData(ctx, queryData = {}) {
+  const joinedQueryData = getJoinedContextValue(ctx, "queryData");
+  const existingQueryData = ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : joinedQueryData && typeof joinedQueryData === "object" ? joinedQueryData : {};
+  const nextQueryData = {
+    ...existingQueryData,
+    ...queryData
+  };
+  const resolvedData = Object.prototype.hasOwnProperty.call(ctx, "data") || ctx.data !== void 0 ? ctx.data : getJoinedContextValue(ctx, "data");
+  const resolvedBatch = Object.prototype.hasOwnProperty.call(ctx, "batch") || ctx.batch !== void 0 ? ctx.batch : getJoinedContextValue(ctx, "batch");
+  if (!("data" in nextQueryData) && resolvedData !== void 0) {
+    nextQueryData.data = resolvedData && typeof resolvedData === "object" && !Array.isArray(resolvedData) ? { ...resolvedData } : resolvedData;
+  }
+  if (!("batch" in nextQueryData) && resolvedBatch !== void 0) {
+    nextQueryData.batch = Array.isArray(resolvedBatch) ? resolvedBatch.map(
+      (row) => row && typeof row === "object" ? { ...row } : row
+    ) : resolvedBatch;
+  }
+  return nextQueryData;
+}
 function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, options = {}) {
   const localInsertTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName);
-  if (localInsertTask) {
-    const taskWithSyncQueryData = localInsertTask;
-    taskWithSyncQueryData[LOCAL_SYNC_QUERY_DATA] = {
-      ...taskWithSyncQueryData[LOCAL_SYNC_QUERY_DATA] ?? {},
-      ...queryData
-    };
-    if (!taskWithSyncQueryData[LOCAL_SYNC_ORIGINAL_TASK_FUNCTION]) {
-      taskWithSyncQueryData[LOCAL_SYNC_ORIGINAL_TASK_FUNCTION] = taskWithSyncQueryData.taskFunction;
-      taskWithSyncQueryData.taskFunction = (ctx, emit, inquire, progressCallback) => {
-        const existingQueryData = ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : {};
-        const syncQueryData = taskWithSyncQueryData[LOCAL_SYNC_QUERY_DATA] ?? {};
-        const nextContext = ctx.__syncing ? {
+  const remoteInsertTask = isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(tableName, queryData, options) : void 0;
+  if (!localInsertTask && !remoteInsertTask) {
+    return void 0;
+  }
+  return CadenzaService.createUniqueMetaTask(
+    `Resolve graph sync insert for ${tableName}`,
+    (ctx, emit, inquire, progressCallback) => {
+      const targetTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName) ?? remoteInsertTask;
+      if (!targetTask) {
+        return false;
+      }
+      return targetTask.taskFunction(
+        {
           ...ctx,
-          queryData: {
-            ...existingQueryData,
-            ...syncQueryData,
-            data: ctx.data && typeof ctx.data === "object" ? { ...ctx.data } : ctx.data
-          }
-        } : ctx;
-        return taskWithSyncQueryData[LOCAL_SYNC_ORIGINAL_TASK_FUNCTION](
-          nextContext,
-          emit,
-          inquire,
-          progressCallback
-        );
-      };
+          queryData: buildSyncInsertQueryData(
+            ctx,
+            queryData
+          )
+        },
+        emit,
+        inquire,
+        progressCallback
+      );
+    },
+    `Routes graph sync inserts for ${tableName} through the local authority task when available.`,
+    {
+      ...options,
+      register: false,
+      isHidden: true
     }
-    return localInsertTask;
-  }
-  return isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(tableName, queryData, options) : void 0;
+  );
 }
 var CADENZA_DB_REQUIRED_LOCAL_SYNC_INSERT_TABLES = [
   "intent_registry",
@@ -8234,11 +8389,13 @@ var GraphSyncController = class _GraphSyncController {
     this.registeredActors = /* @__PURE__ */ new Set();
     this.registeredActorTaskMaps = /* @__PURE__ */ new Set();
     this.registeredIntentDefinitions = /* @__PURE__ */ new Set();
-    this.loggedAuthorityTaskIntentDiagnostics = /* @__PURE__ */ new Set();
+    this.tasksSynced = false;
+    this.signalsSynced = false;
+    this.intentsSynced = false;
+    this.routinesSynced = false;
     this.isCadenzaDBReady = false;
     this.initialized = false;
     this.initRetryScheduled = false;
-    this.loggedCadenzaDBIntentSweep = false;
     this.lastMissingLocalCadenzaDBInsertTablesKey = "";
   }
   static get instance() {
@@ -8313,21 +8470,36 @@ var GraphSyncController = class _GraphSyncController {
       },
       { concurrency: 30 }
     );
+    const ensureIntentRegistryBeforeIntentMapTask = resolveSyncInsertTask(
+      this.isCadenzaDBReady,
+      "intent_registry",
+      {
+        onConflict: {
+          target: ["name"],
+          action: {
+            do: "nothing"
+          }
+        }
+      },
+      { concurrency: 30 }
+    );
     this.splitRoutinesTask = CadenzaService.createMetaTask(
       "Split routines for registration",
-      async function* (ctx, emit) {
+      (ctx, emit) => {
         const { routines } = ctx;
-        if (!routines) return;
+        if (!routines) return false;
         const serviceName2 = resolveSyncServiceName();
         if (!serviceName2) {
-          return;
+          return false;
         }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 2e3
         });
+        let emittedCount = 0;
         for (const routine of routines) {
           if (routine.registered) continue;
-          yield {
+          emit("meta.sync_controller.routine_registration_split", {
+            __syncing: ctx.__syncing,
             data: {
               name: routine.name,
               version: routine.version,
@@ -8336,10 +8508,13 @@ var GraphSyncController = class _GraphSyncController {
               isMeta: routine.isMeta
             },
             __routineName: routine.name
-          };
+          });
+          emittedCount += 1;
         }
+        return emittedCount > 0;
       }
-    ).then(
+    );
+    CadenzaService.createMetaTask("Process split routine registration", (ctx) => ctx).doOn("meta.sync_controller.routine_registration_split").then(
       resolveSyncInsertTask(
         this.isCadenzaDBReady,
         "routine",
@@ -8354,39 +8529,46 @@ var GraphSyncController = class _GraphSyncController {
         { concurrency: 30 }
       )?.then(
         CadenzaService.createMetaTask("Register routine", (ctx) => {
-          if (!ctx.__syncing) {
+          if (!ctx.__syncing || !didSyncInsertSucceed(ctx)) {
             return;
           }
           CadenzaService.debounce("meta.sync_controller.synced_resource", {
             delayMs: 3e3
           });
           CadenzaService.getRoutine(ctx.__routineName).registered = true;
+          CadenzaService.debounce(
+            "meta.sync_controller.routine_registration_settled",
+            { __syncing: true },
+            300
+          );
           return true;
-        }).then(
-          CadenzaService.createUniqueMetaTask(
-            "Gather routine registration",
-            () => true
-          ).emits("meta.sync_controller.synced_routines")
-        )
+        })
       )
     );
+    CadenzaService.createUniqueMetaTask(
+      "Gather routine registration",
+      () => {
+        this.routinesSynced = true;
+        return true;
+      }
+    ).doOn("meta.sync_controller.routine_registration_settled").emits("meta.sync_controller.synced_routines");
     this.splitTasksInRoutines = CadenzaService.createMetaTask(
       "Split tasks in routines",
-      function* (ctx) {
+      (ctx, emit) => {
         const { routines } = ctx;
-        if (!routines) return;
+        if (!routines) return false;
         const serviceName2 = resolveSyncServiceName();
         if (!serviceName2) {
-          return;
+          return false;
         }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
+        let emittedCount = 0;
         for (const routine of routines) {
           if (!routine.registered) continue;
           for (const task of routine.tasks) {
             if (!task) {
-              console.log("task is null", routine, task);
               continue;
             }
             if (routine.registeredTasks.has(task.name)) continue;
@@ -8396,7 +8578,8 @@ var GraphSyncController = class _GraphSyncController {
               if (!nextTask?.registered) {
                 continue;
               }
-              yield {
+              emit("meta.sync_controller.routine_task_map_split", {
+                __syncing: ctx.__syncing,
                 data: {
                   taskName: nextTask.name,
                   taskVersion: nextTask.version,
@@ -8406,12 +8589,15 @@ var GraphSyncController = class _GraphSyncController {
                 },
                 __routineName: routine.name,
                 __taskName: nextTask.name
-              };
+              });
+              emittedCount += 1;
             }
           }
         }
+        return emittedCount > 0;
       }
-    ).then(
+    );
+    CadenzaService.createMetaTask("Process split routine task map", (ctx) => ctx).doOn("meta.sync_controller.routine_task_map_split").then(
       resolveSyncInsertTask(
         this.isCadenzaDBReady,
         "task_to_routine_map",
@@ -8432,7 +8618,7 @@ var GraphSyncController = class _GraphSyncController {
         { concurrency: 30 }
       )?.then(
         CadenzaService.createMetaTask("Register routine task", (ctx) => {
-          if (!ctx.__syncing) {
+          if (!ctx.__syncing || !didSyncInsertSucceed(ctx)) {
             return;
           }
           CadenzaService.debounce("meta.sync_controller.synced_resource", {
@@ -8446,18 +8632,19 @@ var GraphSyncController = class _GraphSyncController {
     );
     this.splitSignalsTask = CadenzaService.createMetaTask(
       "Split signals for registration",
-      function* (ctx) {
+      (ctx, emit) => {
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
         const { signals } = ctx;
-        if (!signals) return;
+        if (!signals) return false;
         const filteredSignals = signals.filter(
           (signal) => !signal.data.registered
         ).map((signal) => signal.signal);
         for (const signal of filteredSignals) {
           const { isMeta, isGlobal, domain, action } = decomposeSignalName(signal);
-          yield {
+          emit("meta.sync_controller.signal_registration_split", {
+            __syncing: ctx.__syncing,
             data: {
               name: signal,
               isGlobal,
@@ -8466,10 +8653,12 @@ var GraphSyncController = class _GraphSyncController {
               isMeta
             },
             __signal: signal
-          };
+          });
         }
+        return filteredSignals.length > 0;
       }
-    ).then(
+    );
+    CadenzaService.createMetaTask("Process split signal registration", (ctx) => ctx).doOn("meta.sync_controller.signal_registration_split").then(
       resolveSyncInsertTask(
         this.isCadenzaDBReady,
         "signal_registry",
@@ -8484,37 +8673,45 @@ var GraphSyncController = class _GraphSyncController {
         { concurrency: 30 }
       )?.then(
         CadenzaService.createMetaTask("Process signal registration", (ctx) => {
-          if (!ctx.__syncing) {
+          if (!ctx.__syncing || !didSyncInsertSucceed(ctx)) {
             return;
           }
           CadenzaService.debounce("meta.sync_controller.synced_resource", {
             delayMs: 3e3
           });
+          CadenzaService.debounce(
+            "meta.sync_controller.signal_registration_settled",
+            { __syncing: true },
+            300
+          );
           return { signalName: ctx.__signal };
-        }).then(
-          CadenzaService.signalBroker.registerSignalTask,
-          CadenzaService.createUniqueMetaTask(
-            "Gather signal registration",
-            () => true
-          ).emits("meta.sync_controller.synced_signals")
-        )
+        }).then(CadenzaService.signalBroker.registerSignalTask)
       )
     );
+    CadenzaService.createUniqueMetaTask(
+      "Gather signal registration",
+      () => {
+        this.signalsSynced = true;
+        return true;
+      }
+    ).doOn("meta.sync_controller.signal_registration_settled").emits("meta.sync_controller.synced_signals");
     this.splitTasksForRegistration = CadenzaService.createMetaTask(
       "Split tasks for registration",
-      function* (ctx) {
+      (ctx, emit) => {
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
         const tasks = ctx.tasks;
         const serviceName2 = resolveSyncServiceName();
         if (!serviceName2) {
-          return;
+          return false;
         }
+        let emittedCount = 0;
         for (const task of tasks) {
           if (task.registered) continue;
           const { __functionString, __getTagCallback } = task.export();
-          yield {
+          emit("meta.sync_controller.task_registration_split", {
+            __syncing: ctx.__syncing,
             data: {
               name: task.name,
               version: task.version,
@@ -8532,9 +8729,7 @@ var GraphSyncController = class _GraphSyncController {
               isMeta: task.isMeta,
               isSubMeta: task.isSubMeta,
               isHidden: task.isHidden,
-              // inputSchema: task.inputSchema,
               validateInputContext: task.validateInputContext,
-              // outputSchema: task.outputSchema,
               validateOutputContext: task.validateOutputContext,
               retryCount: task.retryCount,
               retryDelay: task.retryDelay,
@@ -8549,10 +8744,13 @@ var GraphSyncController = class _GraphSyncController {
               }
             },
             __taskName: task.name
-          };
+          });
+          emittedCount += 1;
         }
+        return emittedCount > 0;
       }
-    ).then(
+    );
+    CadenzaService.createMetaTask("Process split task registration", (ctx) => ctx).doOn("meta.sync_controller.task_registration_split").then(
       resolveSyncInsertTask(
         this.isCadenzaDBReady,
         "task",
@@ -8567,7 +8765,7 @@ var GraphSyncController = class _GraphSyncController {
         { concurrency: 30 }
       )?.then(
         CadenzaService.createMetaTask("Record registration", (ctx, emit) => {
-          if (!ctx.__syncing) {
+          if (!ctx.__syncing || !didSyncInsertSucceed(ctx)) {
             return;
           }
           CadenzaService.debounce("meta.sync_controller.synced_resource", {
@@ -8578,15 +8776,22 @@ var GraphSyncController = class _GraphSyncController {
             ...ctx,
             task: CadenzaService.get(ctx.__taskName)
           });
+          CadenzaService.debounce(
+            "meta.sync_controller.task_registration_settled",
+            { __syncing: true },
+            300
+          );
           return true;
-        }).then(
-          CadenzaService.createUniqueMetaTask(
-            "Gather task registration",
-            () => true
-          ).emits("meta.sync_controller.synced_tasks")
-        )
+        })
       )
     );
+    CadenzaService.createUniqueMetaTask(
+      "Gather task registration",
+      () => {
+        this.tasksSynced = true;
+        return true;
+      }
+    ).doOn("meta.sync_controller.task_registration_settled").emits("meta.sync_controller.synced_tasks");
     this.splitActorsForRegistration = CadenzaService.createMetaTask(
       "Split actors for registration",
       function* (ctx) {
@@ -8631,22 +8836,26 @@ var GraphSyncController = class _GraphSyncController {
         { concurrency: 30 }
       )?.then(
         CadenzaService.createMetaTask("Record actor registration", (ctx) => {
-          if (!ctx.__syncing) {
+          if (!ctx.__syncing || !didSyncInsertSucceed(ctx)) {
             return;
           }
           CadenzaService.debounce("meta.sync_controller.synced_resource", {
             delayMs: 3e3
           });
           this.registeredActors.add(ctx.__actorRegistrationKey);
+          CadenzaService.debounce(
+            "meta.sync_controller.actor_registration_settled",
+            { __syncing: true },
+            300
+          );
           return true;
-        }).then(
-          CadenzaService.createUniqueMetaTask(
-            "Gather actor registration",
-            () => true
-          ).emits("meta.sync_controller.synced_actors")
-        )
+        })
       )
     );
+    CadenzaService.createUniqueMetaTask(
+      "Gather actor registration",
+      () => true
+    ).doOn("meta.sync_controller.actor_registration_settled").emits("meta.sync_controller.synced_actors");
     this.registerActorTaskMapTask = CadenzaService.createMetaTask(
       "Split actor task maps",
       function* (ctx) {
@@ -8701,7 +8910,7 @@ var GraphSyncController = class _GraphSyncController {
         { concurrency: 30 }
       )?.then(
         CadenzaService.createMetaTask("Record actor task map registration", (ctx) => {
-          if (!ctx.__syncing) {
+          if (!ctx.__syncing || !didSyncInsertSucceed(ctx)) {
             return;
           }
           CadenzaService.debounce("meta.sync_controller.synced_resource", {
@@ -8714,7 +8923,7 @@ var GraphSyncController = class _GraphSyncController {
     const registerSignalTask = CadenzaService.createMetaTask(
       "Record signal registration",
       (ctx) => {
-        if (!ctx.__syncing) {
+        if (!ctx.__syncing || !didSyncInsertSucceed(ctx)) {
           return;
         }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
@@ -8725,13 +8934,14 @@ var GraphSyncController = class _GraphSyncController {
     );
     this.registerSignalToTaskMapTask = CadenzaService.createMetaTask(
       "Split observed signals of task",
-      function* (ctx) {
+      (ctx, emit) => {
         const task = ctx.task;
-        if (task.hidden || !task.register) return;
+        if (task.hidden || !task.register) return false;
         const serviceName2 = resolveSyncServiceName(task);
         if (!serviceName2) {
-          return;
+          return false;
         }
+        let emittedCount = 0;
         for (const signal of task.observedSignals) {
           const _signal = signal.split(":")[0];
           if (task.registeredSignals.has(signal)) continue;
@@ -8739,7 +8949,8 @@ var GraphSyncController = class _GraphSyncController {
             continue;
           }
           const { isGlobal } = decomposeSignalName(_signal);
-          yield {
+          emit("meta.sync_controller.signal_task_map_split", {
+            __syncing: ctx.__syncing,
             data: {
               signalName: _signal,
               isGlobal,
@@ -8749,10 +8960,13 @@ var GraphSyncController = class _GraphSyncController {
             },
             __taskName: task.name,
             __signal: signal
-          };
+          });
+          emittedCount += 1;
         }
+        return emittedCount > 0;
       }
-    ).then(
+    );
+    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",
@@ -8774,29 +8988,12 @@ var GraphSyncController = class _GraphSyncController {
     );
     this.splitIntentsTask = CadenzaService.createMetaTask(
       "Split intents for registration",
-      function* (ctx) {
+      function(ctx, emit) {
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
         const intents = Array.isArray(ctx.intents) ? ctx.intents : Array.from(CadenzaService.inquiryBroker.intents.values());
-        if (resolveSyncServiceName() === "CadenzaDB" && !this.loggedCadenzaDBIntentSweep) {
-          const intentNames = intents.map((intent) => String(intent?.name ?? "").trim()).filter(Boolean);
-          const authorityIntentNames = intentNames.filter(
-            (intentName) => intentName === "meta-service-registry-full-sync" || intentName.includes("service_instance") || intentName.includes("service_instance_transport") || intentName.includes("intent_to_task_map") || intentName.includes("signal_to_task_map")
-          );
-          CadenzaService.log(
-            "CadenzaDB intent sweep diagnostics.",
-            {
-              totalIntents: intentNames.length,
-              hasMetaServiceRegistryFullSync: intentNames.includes(
-                "meta-service-registry-full-sync"
-              ),
-              authorityIntentNames
-            },
-            "info"
-          );
-          this.loggedCadenzaDBIntentSweep = true;
-        }
+        let emittedCount = 0;
         for (const intent of intents) {
           const intentData = buildIntentRegistryData(intent);
           if (!intentData) {
@@ -8805,35 +9002,46 @@ var GraphSyncController = class _GraphSyncController {
           if (this.registeredIntentDefinitions.has(intentData.name)) {
             continue;
           }
-          yield {
+          emit("meta.sync_controller.intent_registration_split", {
+            __syncing: ctx.__syncing,
             data: intentData,
             __intentName: intentData.name
-          };
+          });
+          emittedCount += 1;
         }
+        return emittedCount > 0;
       }.bind(this)
-    ).then(
+    );
+    CadenzaService.createMetaTask("Process split intent registration", (ctx) => ctx).doOn("meta.sync_controller.intent_registration_split").then(
       insertIntentRegistryTask?.then(
         CadenzaService.createMetaTask("Record intent definition registration", (ctx) => {
-          if (!ctx.__syncing) {
+          if (!ctx.__syncing || !didSyncInsertSucceed(ctx)) {
             return;
           }
           CadenzaService.debounce("meta.sync_controller.synced_resource", {
             delayMs: 3e3
           });
           this.registeredIntentDefinitions.add(ctx.__intentName);
+          CadenzaService.debounce(
+            "meta.sync_controller.intent_registration_settled",
+            { __syncing: true },
+            300
+          );
           return true;
-        }).then(
-          CadenzaService.createUniqueMetaTask(
-            "Gather intent registration",
-            () => true
-          ).emits("meta.sync_controller.synced_intents")
-        )
+        })
       )
     );
+    CadenzaService.createUniqueMetaTask(
+      "Gather intent registration",
+      () => {
+        this.intentsSynced = true;
+        return true;
+      }
+    ).doOn("meta.sync_controller.intent_registration_settled").emits("meta.sync_controller.synced_intents");
     const registerIntentTask = CadenzaService.createMetaTask(
       "Record intent registration",
       (ctx) => {
-        if (!ctx.__syncing) {
+        if (!ctx.__syncing || !didSyncInsertSucceed(ctx)) {
           return;
         }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
@@ -8846,37 +9054,15 @@ var GraphSyncController = class _GraphSyncController {
     );
     this.registerIntentToTaskMapTask = CadenzaService.createMetaTask(
       "Split intents of task",
-      function* (ctx) {
+      function(ctx, emit) {
         const task = ctx.task;
-        if (task.hidden || !task.register) return;
+        if (task.hidden || !task.register) return false;
         const serviceName2 = resolveSyncServiceName(task);
         if (!serviceName2) {
-          return;
+          return false;
         }
         task.__registeredIntents = task.__registeredIntents ?? /* @__PURE__ */ new Set();
         task.__invalidMetaIntentWarnings = task.__invalidMetaIntentWarnings ?? /* @__PURE__ */ new Set();
-        if (serviceName2 === "CadenzaDB" && [
-          "Query service_instance",
-          "Query service_instance_transport",
-          "Query intent_to_task_map",
-          "Query signal_to_task_map"
-        ].includes(task.name)) {
-          const authorityTaskKey = `${task.name}:${task.version}`;
-          if (!this.loggedAuthorityTaskIntentDiagnostics.has(authorityTaskKey)) {
-            this.loggedAuthorityTaskIntentDiagnostics.add(authorityTaskKey);
-            CadenzaService.log(
-              "CadenzaDB authority task intent diagnostics.",
-              {
-                taskName: task.name,
-                taskVersion: task.version,
-                isMeta: task.isMeta,
-                handlesIntents: Array.from(task.handlesIntents ?? []),
-                registeredIntents: Array.from(task.__registeredIntents ?? [])
-              },
-              "info"
-            );
-          }
-        }
         for (const intent of task.handlesIntents) {
           if (task.__registeredIntents.has(intent)) continue;
           if (isMetaIntentName(intent) && !task.isMeta) {
@@ -8898,7 +9084,8 @@ var GraphSyncController = class _GraphSyncController {
           if (!intentDefinition) {
             continue;
           }
-          yield {
+          emit("meta.sync_controller.intent_task_map_split", {
+            __syncing: ctx.__syncing,
             data: {
               intentName: intent,
               taskName: task.name,
@@ -8914,10 +9101,12 @@ var GraphSyncController = class _GraphSyncController {
               taskVersion: task.version,
               serviceName: serviceName2
             }
-          };
+          });
         }
+        return true;
       }.bind(this)
-    ).then(
+    );
+    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) => {
@@ -8930,7 +9119,7 @@ var GraphSyncController = class _GraphSyncController {
           };
         }
       ).then(
-        insertIntentRegistryTask?.then(
+        ensureIntentRegistryBeforeIntentMapTask?.then(
           CadenzaService.createMetaTask(
             "Restore intent-to-task map payload",
             (ctx) => {
@@ -8978,7 +9167,7 @@ var GraphSyncController = class _GraphSyncController {
           return;
         }
         for (const t of task.nextTasks) {
-          if (task.taskMapRegistration.has(t.name) || t.hidden || !t.register) {
+          if (task.taskMapRegistration.has(t.name) || t.hidden || !t.register || !t.registered) {
             continue;
           }
           const serviceName2 = resolveSyncServiceName(t);
@@ -9021,7 +9210,7 @@ var GraphSyncController = class _GraphSyncController {
         { concurrency: 30 }
       )?.then(
         CadenzaService.createMetaTask("Record task map registration", (ctx) => {
-          if (!ctx.__syncing) {
+          if (!ctx.__syncing || !didSyncInsertSucceed(ctx)) {
             return;
           }
           CadenzaService.debounce("meta.sync_controller.synced_resource", {
@@ -9082,7 +9271,7 @@ var GraphSyncController = class _GraphSyncController {
         CadenzaService.createMetaTask(
           "Record deputy relationship registration",
           (ctx) => {
-            if (!ctx.__syncing) {
+            if (!ctx.__syncing || !didSyncInsertSucceed(ctx)) {
               return;
             }
             CadenzaService.debounce("meta.sync_controller.synced_resource", {
@@ -9097,29 +9286,89 @@ var GraphSyncController = class _GraphSyncController {
       "meta.sync_controller.sync_tick",
       "meta.service_registry.initial_sync_complete"
     ).then(this.splitSignalsTask);
-    CadenzaService.registry.getAllTasks.clone().doOn("meta.sync_controller.synced_signals").then(this.splitTasksForRegistration);
+    CadenzaService.registry.getAllTasks.clone().doOn(
+      "meta.sync_controller.sync_tick",
+      "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);
+    }).doOn(
+      "meta.sync_controller.sync_tick",
+      "meta.service_registry.initial_sync_complete"
+    ).then(this.splitIntentsTask);
+    CadenzaService.registry.getAllRoutines.clone().doOn(
+      "meta.sync_controller.sync_tick",
+      "meta.service_registry.initial_sync_complete"
+    ).then(this.splitRoutinesTask);
     CadenzaService.createMetaTask("Get all actors", (ctx) => {
       return {
         ...ctx,
         actors: CadenzaService.getAllActors()
       };
-    }).doOn("meta.sync_controller.synced_tasks").then(this.splitActorsForRegistration);
-    CadenzaService.registry.doForEachTask.clone().doOn("meta.sync_controller.synced_tasks").then(
+    }).doOn(
+      "meta.sync_controller.sync_tick",
+      "meta.service_registry.initial_sync_complete"
+    ).then(this.splitActorsForRegistration);
+    CadenzaService.createMetaTask("Get registered task for task graph sync", (ctx) => {
+      const task = ctx.task ?? (ctx.__taskName ? CadenzaService.get(ctx.__taskName) : void 0);
+      if (!task) {
+        return false;
+      }
+      return {
+        ...ctx,
+        task
+      };
+    }).doOn("meta.sync_controller.task_registered").then(
       this.registerTaskMapTask,
       this.registerDeputyRelationshipTask
     );
     CadenzaService.registry.doForEachTask.clone().doOn(
-      "meta.sync_controller.synced_tasks",
       "meta.sync_controller.synced_signals"
-    ).then(this.registerSignalToTaskMapTask);
-    CadenzaService.registry.doForEachTask.clone().doOn("meta.sync_controller.synced_tasks", "meta.sync_controller.synced_intents").then(this.registerIntentToTaskMapTask);
+    ).then(
+      CadenzaService.createMetaTask(
+        "Ensure signal and task sync ready",
+        (ctx) => {
+          if (!this.tasksSynced || !this.signalsSynced) {
+            return false;
+          }
+          return ctx;
+        }
+      ).then(this.registerSignalToTaskMapTask)
+    );
+    CadenzaService.createMetaTask("Get registered task for signal sync", (ctx) => {
+      const task = ctx.task ?? (ctx.__taskName ? CadenzaService.get(ctx.__taskName) : void 0);
+      if (!task) {
+        return false;
+      }
+      return {
+        ...ctx,
+        task
+      };
+    }).doOn("meta.sync_controller.task_registered").then(
+      CadenzaService.createMetaTask(
+        "Ensure signal and task sync ready from task registration",
+        (ctx) => {
+          if (!this.tasksSynced || !this.signalsSynced) {
+            return false;
+          }
+          return ctx;
+        }
+      ).then(this.registerSignalToTaskMapTask)
+    );
+    CadenzaService.registry.doForEachTask.clone().doOn("meta.sync_controller.synced_intents").then(
+      CadenzaService.createMetaTask(
+        "Ensure intent and task sync ready",
+        (ctx) => {
+          if (!this.tasksSynced || !this.intentsSynced) {
+            return false;
+          }
+          return ctx;
+        }
+      ).then(this.registerIntentToTaskMapTask)
+    );
     CadenzaService.createMetaTask("Get registered task for intent sync", (ctx) => {
       const task = ctx.task ?? (ctx.__taskName ? CadenzaService.get(ctx.__taskName) : void 0);
       if (!task) {
@@ -9129,12 +9378,42 @@ var GraphSyncController = class _GraphSyncController {
         ...ctx,
         task
       };
-    }).doOn("meta.sync_controller.task_registered").then(this.registerIntentToTaskMapTask);
-    CadenzaService.registry.doForEachTask.clone().doOn("meta.sync_controller.synced_tasks", "meta.sync_controller.synced_actors").then(this.registerActorTaskMapTask);
+    }).doOn("meta.sync_controller.task_registered").then(
+      CadenzaService.createMetaTask(
+        "Ensure intent and task sync ready from task registration",
+        (ctx) => {
+          if (!this.tasksSynced || !this.intentsSynced) {
+            return false;
+          }
+          return ctx;
+        }
+      ).then(this.registerIntentToTaskMapTask)
+    );
+    CadenzaService.registry.doForEachTask.clone().doOn("meta.sync_controller.synced_actors").then(this.registerActorTaskMapTask);
+    CadenzaService.createMetaTask("Get registered task for actor sync", (ctx) => {
+      const task = ctx.task ?? (ctx.__taskName ? CadenzaService.get(ctx.__taskName) : void 0);
+      if (!task) {
+        return false;
+      }
+      return {
+        ...ctx,
+        task
+      };
+    }).doOn("meta.sync_controller.task_registered").then(this.registerActorTaskMapTask);
     CadenzaService.registry.getAllRoutines.clone().doOn(
-      "meta.sync_controller.synced_tasks",
-      "meta.sync_controller.synced_routines"
-    ).then(this.splitTasksInRoutines);
+      "meta.sync_controller.synced_routines",
+      "meta.sync_controller.task_registered"
+    ).then(
+      CadenzaService.createMetaTask(
+        "Ensure routine and task sync ready",
+        (ctx) => {
+          if (!this.tasksSynced || !this.routinesSynced) {
+            return false;
+          }
+          return ctx;
+        }
+      ).then(this.splitTasksInRoutines)
+    );
     CadenzaService.createMetaTask("Finish sync", (ctx, emit) => {
       emit("global.meta.sync_controller.synced", {
         data: {
@@ -10262,6 +10541,12 @@ var CadenzaService = class {
         displayName: options.displayName ?? "",
         isMeta: options.isMeta
       },
+      __registrationData: {
+        name: serviceName,
+        description,
+        displayName: options.displayName ?? "",
+        isMeta: options.isMeta
+      },
       __serviceName: serviceName,
       __serviceInstanceId: serviceId,
       __port: options.port,
@@ -10314,6 +10599,16 @@ var CadenzaService = class {
             is_blocked: false,
             health: {}
           },
+          __registrationData: {
+            uuid: serviceId,
+            process_pid: 1,
+            service_name: serviceName,
+            is_frontend: true,
+            is_active: true,
+            is_non_responsive: false,
+            is_blocked: false,
+            health: {}
+          },
           __transportData: [],
           __serviceName: serviceName,
           __serviceInstanceId: serviceId,