@cadenza.io/service 2.17.48 → 2.17.49

package/dist/index.js

@@ -9016,6 +9016,31 @@ function resolveSyncQueryTask(isCadenzaDBReady, tableName, queryData = {}, optio
     }
   ).then(targetTask);
 }
+function getRegistrableTasks() {
+  return Array.from(CadenzaService.registry.tasks.values()).filter(
+    (task) => task.register && !task.isHidden
+  );
+}
+function getRegistrableRoutines() {
+  return Array.from(CadenzaService.registry.routines.values());
+}
+function getRegistrableSignalObservers() {
+  const signalObservers = CadenzaService.signalBroker.signalObservers;
+  return signalObservers ? Array.from(signalObservers.values()) : [];
+}
+function getRegistrableIntentNames() {
+  return Array.from(CadenzaService.inquiryBroker.intents.values()).map((intent) => buildIntentRegistryData(intent)).filter(
+    (intentDefinition) => intentDefinition !== null
+  ).map((intentDefinition) => String(intentDefinition.name));
+}
+function buildActorRegistrationKey(actor, serviceName) {
+  const data = buildActorRegistrationData(actor);
+  const name = typeof data.name === "string" && data.name.trim().length > 0 ? data.name.trim() : "";
+  if (!name) {
+    return null;
+  }
+  return `${name}|${data.version}|${serviceName}`;
+}
 var GraphSyncController = class _GraphSyncController {
   constructor() {
     this.registeredActors = /* @__PURE__ */ new Set();
@@ -9140,22 +9165,158 @@ var GraphSyncController = class _GraphSyncController {
       {},
       { concurrency: 10 }
     );
+    const finalizeTaskSync = (emit, ctx) => {
+      const pendingTasks = getRegistrableTasks().filter((task) => !task.registered);
+      if (pendingTasks.length > 0) {
+        this.tasksSynced = false;
+        return false;
+      }
+      const shouldEmit = !this.tasksSynced;
+      this.tasksSynced = true;
+      if (shouldEmit) {
+        emit("meta.sync_controller.synced_tasks", {
+          __syncing: true,
+          ...ctx
+        });
+      }
+      return true;
+    };
+    const finalizeRoutineSync = (emit, ctx) => {
+      const pendingRoutines = getRegistrableRoutines().filter(
+        (routine) => !routine.registered
+      );
+      if (pendingRoutines.length > 0) {
+        this.routinesSynced = false;
+        return false;
+      }
+      const shouldEmit = !this.routinesSynced;
+      this.routinesSynced = true;
+      if (shouldEmit) {
+        emit("meta.sync_controller.synced_routines", {
+          __syncing: true,
+          ...ctx
+        });
+      }
+      return true;
+    };
+    const finalizeSignalSync = (emit, ctx) => {
+      const pendingSignals = getRegistrableSignalObservers().filter(
+        (observer) => observer?.registered !== true
+      );
+      if (pendingSignals.length > 0) {
+        this.signalsSynced = false;
+        return false;
+      }
+      const shouldEmit = !this.signalsSynced;
+      this.signalsSynced = true;
+      if (shouldEmit) {
+        emit("meta.sync_controller.synced_signals", {
+          __syncing: true,
+          ...ctx
+        });
+      }
+      return true;
+    };
+    const finalizeIntentSync = (emit, ctx) => {
+      const pendingIntentNames = getRegistrableIntentNames().filter(
+        (intentName) => !this.registeredIntentDefinitions.has(intentName)
+      );
+      if (pendingIntentNames.length > 0) {
+        this.intentsSynced = false;
+        return false;
+      }
+      const shouldEmit = !this.intentsSynced;
+      this.intentsSynced = true;
+      if (shouldEmit) {
+        emit("meta.sync_controller.synced_intents", {
+          __syncing: true,
+          ...ctx
+        });
+      }
+      return true;
+    };
+    const finalizeActorSync = (emit, ctx) => {
+      const syncServiceName = resolveSyncServiceName();
+      if (!syncServiceName) {
+        this.actorsSynced = false;
+        return false;
+      }
+      const pendingActorKeys = CadenzaService.getAllActors().map((actor) => buildActorRegistrationKey(actor, syncServiceName)).filter((registrationKey) => Boolean(registrationKey)).filter((registrationKey) => !this.registeredActors.has(registrationKey));
+      if (pendingActorKeys.length > 0) {
+        this.actorsSynced = false;
+        return false;
+      }
+      const shouldEmit = !this.actorsSynced;
+      this.actorsSynced = true;
+      if (shouldEmit) {
+        emit("meta.sync_controller.synced_actors", {
+          __syncing: true,
+          ...ctx
+        });
+      }
+      return true;
+    };
+    const gatherTaskRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather task registration",
+      (ctx, emit) => finalizeTaskSync(emit, ctx),
+      "Completes task registration when all registrable tasks are marked registered.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const gatherRoutineRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather routine registration",
+      (ctx, emit) => finalizeRoutineSync(emit, ctx),
+      "Completes routine registration when all registrable routines are marked registered.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const gatherSignalRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather signal registration",
+      (ctx, emit) => finalizeSignalSync(emit, ctx),
+      "Completes signal registration when all signal observers are marked registered.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const gatherIntentRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather intent registration",
+      (ctx, emit) => finalizeIntentSync(emit, ctx),
+      "Completes intent registration when all registrable intents are marked registered.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const gatherActorRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather actor registration",
+      (ctx, emit) => finalizeActorSync(emit, ctx),
+      "Completes actor registration when all registrable actors are marked registered.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
     this.splitRoutinesTask = CadenzaService.createMetaTask(
       "Split routines for registration",
-      (ctx, emit) => {
+      function* (ctx) {
         const { routines } = ctx;
-        if (!routines) return false;
+        if (!routines) return;
         const serviceName2 = resolveSyncServiceName();
         if (!serviceName2) {
-          return false;
+          return;
         }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 2e3
         });
-        let emittedCount = 0;
         for (const routine of routines) {
           if (routine.registered) continue;
-          emit("meta.sync_controller.routine_registration_split", {
+          this.routinesSynced = false;
+          yield {
             __syncing: ctx.__syncing,
             data: {
               name: routine.name,
@@ -9165,13 +9326,11 @@ var GraphSyncController = class _GraphSyncController {
               isMeta: routine.isMeta
             },
             __routineName: routine.name
-          });
-          emittedCount += 1;
+          };
         }
-        return emittedCount > 0;
-      }
+      }.bind(this)
     );
-    CadenzaService.createMetaTask("Process split routine registration", (ctx) => ctx).doOn("meta.sync_controller.routine_registration_split").then(
+    this.splitRoutinesTask.then(
       resolveSyncInsertTask(
         this.isCadenzaDBReady,
         "routine",
@@ -9193,22 +9352,10 @@ var GraphSyncController = class _GraphSyncController {
             delayMs: 3e3
           });
           CadenzaService.getRoutine(ctx.__routineName).registered = true;
-          CadenzaService.debounce(
-            "meta.sync_controller.routine_registration_settled",
-            { __syncing: true },
-            300
-          );
           return true;
-        })
+        }).then(gatherRoutineRegistrationTask)
       )
     );
-    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) {
@@ -9297,18 +9444,19 @@ var GraphSyncController = class _GraphSyncController {
     }
     this.splitSignalsTask = CadenzaService.createMetaTask(
       "Split signals for registration",
-      (ctx, emit) => {
+      function* (ctx) {
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
         const { signals } = ctx;
-        if (!signals) return false;
+        if (!signals) return;
         const filteredSignals = signals.filter(
           (signal) => !signal.data.registered
         ).map((signal) => signal.signal);
         for (const signal of filteredSignals) {
           const { isMeta, isGlobal, domain, action } = decomposeSignalName(signal);
-          emit("meta.sync_controller.signal_registration_split", {
+          this.signalsSynced = false;
+          yield {
             __syncing: ctx.__syncing,
             data: {
               name: signal,
@@ -9318,12 +9466,11 @@ var GraphSyncController = class _GraphSyncController {
               isMeta
             },
             __signal: signal
-          });
+          };
         }
-        return filteredSignals.length > 0;
-      }
+      }.bind(this)
     );
-    CadenzaService.createMetaTask("Process split signal registration", (ctx) => ctx).doOn("meta.sync_controller.signal_registration_split").then(
+    this.splitSignalsTask.then(
       resolveSyncInsertTask(
         this.isCadenzaDBReady,
         "signal_registry",
@@ -9344,22 +9491,10 @@ var GraphSyncController = class _GraphSyncController {
           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)
+        }).then(CadenzaService.signalBroker.registerSignalTask).then(gatherSignalRegistrationTask)
       )
     );
-    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) {
@@ -9374,6 +9509,7 @@ var GraphSyncController = class _GraphSyncController {
         for (const task of tasks) {
           if (task.registered) continue;
           const { __functionString, __getTagCallback } = task.export();
+          this.tasksSynced = false;
           if (shouldDebugSyncTaskName(task.name)) {
             logSyncDebug("task_registration_split", {
               taskName: task.name,
@@ -9422,7 +9558,7 @@ var GraphSyncController = class _GraphSyncController {
             __taskName: task.name
           };
         }
-      }
+      }.bind(this)
     );
     const registerTaskTask = resolveSyncInsertTask(
       this.isCadenzaDBReady,
@@ -9456,13 +9592,8 @@ var GraphSyncController = class _GraphSyncController {
           ...ctx,
           task: CadenzaService.get(ctx.__taskName)
         });
-        CadenzaService.debounce(
-          "meta.sync_controller.task_registration_settled",
-          { __syncing: true },
-          300
-        );
         return true;
-      })
+      }).then(gatherTaskRegistrationTask)
     );
     if (registerTaskTask) {
       this.splitTasksForRegistration.then(registerTaskTask);
@@ -9495,13 +9626,6 @@ var GraphSyncController = class _GraphSyncController {
         isHidden: true
       }
     ).doOn("meta.task.created").then(this.splitTasksForRegistration);
-    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) {
@@ -9525,6 +9649,7 @@ var GraphSyncController = class _GraphSyncController {
           if (this.registeredActors.has(registrationKey)) {
             continue;
           }
+          this.actorsSynced = false;
           yield {
             data,
             __actorRegistrationKey: registrationKey
@@ -9553,22 +9678,10 @@ var GraphSyncController = class _GraphSyncController {
             delayMs: 3e3
           });
           this.registeredActors.add(ctx.__actorRegistrationKey);
-          CadenzaService.debounce(
-            "meta.sync_controller.actor_registration_settled",
-            { __syncing: true },
-            300
-          );
           return true;
-        })
+        }).then(gatherActorRegistrationTask)
       )
     );
-    CadenzaService.createUniqueMetaTask(
-      "Gather actor registration",
-      () => {
-        this.actorsSynced = true;
-        return true;
-      }
-    ).doOn("meta.sync_controller.actor_registration_settled").emits("meta.sync_controller.synced_actors");
     this.registerActorTaskMapTask = CadenzaService.createMetaTask(
       "Split actor task maps",
       function* (ctx) {
@@ -9715,12 +9828,11 @@ var GraphSyncController = class _GraphSyncController {
     );
     this.splitIntentsTask = CadenzaService.createMetaTask(
       "Split intents for registration",
-      function(ctx, emit) {
+      function* (ctx) {
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
         const intents = Array.isArray(ctx.intents) ? ctx.intents : Array.from(CadenzaService.inquiryBroker.intents.values());
-        let emittedCount = 0;
         for (const intent of intents) {
           const intentData = buildIntentRegistryData(intent);
           if (!intentData) {
@@ -9729,17 +9841,16 @@ var GraphSyncController = class _GraphSyncController {
           if (this.registeredIntentDefinitions.has(intentData.name)) {
             continue;
           }
-          emit("meta.sync_controller.intent_registration_split", {
+          this.intentsSynced = false;
+          yield {
             __syncing: ctx.__syncing,
             data: intentData,
             __intentName: intentData.name
-          });
-          emittedCount += 1;
+          };
         }
-        return emittedCount > 0;
       }.bind(this)
     );
-    CadenzaService.createMetaTask("Process split intent registration", (ctx) => ctx).doOn("meta.sync_controller.intent_registration_split").then(
+    this.splitIntentsTask.then(
       insertIntentRegistryTask?.then(
         CadenzaService.createMetaTask("Record intent definition registration", (ctx) => {
           if (!didSyncInsertSucceed(ctx)) {
@@ -9749,22 +9860,10 @@ var GraphSyncController = class _GraphSyncController {
             delayMs: 3e3
           });
           this.registeredIntentDefinitions.add(ctx.__intentName);
-          CadenzaService.debounce(
-            "meta.sync_controller.intent_registration_settled",
-            { __syncing: true },
-            300
-          );
           return true;
-        })
+        }).then(gatherIntentRegistrationTask)
       )
     );
-    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) => {
@@ -10058,15 +10157,11 @@ var GraphSyncController = class _GraphSyncController {
             __authoritativeReconciliation: true
           });
         }
-        if (authoritativeTasks.length > 0) {
-          CadenzaService.debounce(
-            "meta.sync_controller.task_registration_settled",
-            {
-              __syncing: true,
-              __authoritativeReconciliation: true
-            },
-            300
-          );
+        if (authoritativeTasks.length > 0 || changed) {
+          finalizeTaskSync(emit, {
+            ...ctx,
+            __authoritativeReconciliation: true
+          });
         }
         return changed;
       },
@@ -10078,7 +10173,7 @@ var GraphSyncController = class _GraphSyncController {
     );
     const reconcileRoutineRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
       "Reconcile routine registration from authority",
-      (ctx) => {
+      (ctx, emit) => {
         const authoritativeRoutines = resolveSyncQueryRows(ctx, "routine");
         let changed = false;
         for (const row of authoritativeRoutines) {
@@ -10093,15 +10188,11 @@ var GraphSyncController = class _GraphSyncController {
           routine.registered = true;
           changed = true;
         }
-        if (authoritativeRoutines.length > 0) {
-          CadenzaService.debounce(
-            "meta.sync_controller.routine_registration_settled",
-            {
-              __syncing: true,
-              __authoritativeReconciliation: true
-            },
-            300
-          );
+        if (authoritativeRoutines.length > 0 || changed) {
+          finalizeRoutineSync(emit, {
+            ...ctx,
+            __authoritativeReconciliation: true
+          });
         }
         return changed;
       },
@@ -10113,7 +10204,7 @@ var GraphSyncController = class _GraphSyncController {
     );
     const reconcileSignalRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
       "Reconcile signal registration from authority",
-      (ctx) => {
+      (ctx, emit) => {
         const authoritativeSignals = resolveSyncQueryRows(ctx, "signal_registry");
         const signalObservers = CadenzaService.signalBroker.signalObservers;
         let changed = false;
@@ -10129,15 +10220,11 @@ var GraphSyncController = class _GraphSyncController {
           observer.registered = true;
           changed = true;
         }
-        if (authoritativeSignals.length > 0) {
-          CadenzaService.debounce(
-            "meta.sync_controller.signal_registration_settled",
-            {
-              __syncing: true,
-              __authoritativeReconciliation: true
-            },
-            300
-          );
+        if (authoritativeSignals.length > 0 || changed) {
+          finalizeSignalSync(emit, {
+            ...ctx,
+            __authoritativeReconciliation: true
+          });
         }
         return changed;
       },
@@ -10149,7 +10236,7 @@ var GraphSyncController = class _GraphSyncController {
     );
     const reconcileIntentRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
       "Reconcile intent registration from authority",
-      (ctx) => {
+      (ctx, emit) => {
         const authoritativeIntents = resolveSyncQueryRows(ctx, "intent_registry");
         let changed = false;
         for (const row of authoritativeIntents) {
@@ -10163,15 +10250,11 @@ var GraphSyncController = class _GraphSyncController {
           this.registeredIntentDefinitions.add(intentName);
           changed = true;
         }
-        if (authoritativeIntents.length > 0) {
-          CadenzaService.debounce(
-            "meta.sync_controller.intent_registration_settled",
-            {
-              __syncing: true,
-              __authoritativeReconciliation: true
-            },
-            300
-          );
+        if (authoritativeIntents.length > 0 || changed) {
+          finalizeIntentSync(emit, {
+            ...ctx,
+            __authoritativeReconciliation: true
+          });
         }
         return changed;
       },